Add TextCraft-Synth 1.0: 3,154 Harbor tasks (part 6)

tasks/textcraft-synth-train-easy-00602/tests/task.json

@@ -0,0 +1,17 @@
+{
+ "format": "textcraft-task/1",
+ "name": "textcraft-synth-train-easy-00602",
+ "world": "textcraft-synth",
+ "goal": "Craft the following items: 3x t2_i3",
+ "target_items": {
+  "t2_i3": 3
+ },
+ "initial_inventory": {
+  "raw_t4": 13,
+  "raw_t9": 9,
+  "raw_t0": 14,
+  "raw_t5": 18,
+  "raw_o8": 2
+ },
+ "recipes_sha256": "a020eec273337c66b35c0fc487664e35c44da65ad18e9afffe6a4c25af949f10"
+}

tasks/textcraft-synth-train-easy-00602/tests/test.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# Grade a TextCraft episode: replay the agent's action log (/app/textcraft/actions.jsonl) from the task's starting
+# inventory with the game's rules, using this directory's own copies of the game, the recipes and the task.  The
+# reward is 1 only when the log is an episode the rules allow that ends in `textcraft finish` with every target
+# crafted (the verdict goes to textcraft-verdict.json).  It runs in the agent's container (a shared verifier) or in a
+# separate verifier that received the log as an artifact.
+# PLATOON_SANDBOX_ROOT: platoon's process provider runs this on the host, with the sandbox's files below that
+# directory; sandboxes leave it unset.
+set -u
+root="${PLATOON_SANDBOX_ROOT:-}"
+tests="$root/tests"
+out="$root/logs/verifier"
+mkdir -p "$out"
+# A fresh verdict: nothing the agent may have left in the verifier's directory counts.
+rm -rf -- "$out/reward.json" "$out/reward.txt" "$out/textcraft-verdict.json"
+exec python3 -I "$tests/textcraft_game.py" verify --task "$tests/task.json" --recipes "$tests/recipes.json" \
+  --root "$root/" --log app/textcraft/actions.jsonl --out "$out"

tasks/textcraft-synth-train-easy-00602/tests/textcraft_game.py

@@ -0,0 +1,756 @@
+"""TextCraft in a container: the ``textcraft`` command of a Harbor task, and the verifier that grades it.
+
+This one file is the whole game.  It needs Python 3.8 or later and its standard library only, and it never imports
+platoon: the exporter (``python -m platoon.textcraft.harbor export``) copies it into every task as
+``textcraft_game.py``, into ``environment/`` (the container gets it at ``/app/textcraft/textcraft_game.py``, which
+the image's ``textcraft`` command runs) and into ``tests/`` for the verifier.  It reproduces platoon's TextCraft
+environments (``platoon.textcraft.env``): the same four tools with the same arguments, the same observation text
+and the same success rule.
+
+=========================================  ===================  ===============================================
+command                                    environment tool     prints
+=========================================  ===================  ===============================================
+``textcraft craft TARGET COUNT ING=N ...``  ``craft``            ``Successfully crafted ...`` or ``Error: ...``
+``textcraft info ITEM ...``                 ``get_info``         the recipe information, as JSON
+``textcraft inventory``                     ``view_inventory``   the inventory, as JSON
+``textcraft finish MESSAGE``                ``finish``           the message; the episode ends
+=========================================  ===================  ===============================================
+
+``craft --json '{"ingredients": {...}, "target": [item, count]}'`` and ``info --json '[item, ...]'`` take a tool's
+arguments as JSON values, the way a tool call passes them.
+
+**State.**  ``$TEXTCRAFT_DIR`` (default: this file's directory, ``/app/textcraft`` in a task's container) holds the
+task (``task.json``: goal, targets, starting inventory), the world's recipes (``recipes.json``, or
+``$TEXTCRAFT_RECIPES``) and the action log (``actions.jsonl``).  The log is the state: under an exclusive lock,
+every command replays the log from the starting inventory, runs, and appends its own record (``{"seq", "tool",
+"args"}``, plus ``"ok"`` for a craft).  Nothing is accepted after ``finish``, or once the log no longer replays.
+
+**Grading** (``python3 textcraft_game.py verify``, from the task's ``tests/test.sh``) replays the log with trusted
+copies of the task and the recipes.  The reward is 1 when the log is an episode the rules allow that ends in
+``finish`` with a message, and the inventory then holds every target count on top of the starting inventory (the
+environment's rule); otherwise it is 0.  The log must be a regular file of at most 32 MiB, reached without a
+symbolic link below the sandbox root.  A record that does not parse, breaks the record format or the numbering,
+follows ``finish``, or claims a craft outcome the rules do not give ends the replay with reward 0: only a log the
+command could have written earns a reward.  A craft the rules reject, recorded as rejected, changes nothing, as in
+the environment.
+"""
+
+from __future__ import annotations
+
+import argparse
+import errno
+import fcntl
+import hashlib
+import json
+import os
+import stat
+import sys
+
+VERSION = "1.0"
+TASK_FORMAT = "textcraft-task/1"
+RECIPES_FORMAT = "textcraft-recipes/1"
+TASK_FILE = "task.json"
+LOG_FILE = "actions.jsonl"
+RECIPES_FILE = "recipes.json"
+REWARD_FILE = "reward.json"
+VERDICT_FILE = "textcraft-verdict.json"
+LOG_CAP_BYTES = 32 * 1024 * 1024
+CRAFTED = "Successfully crafted"
+# The environment's tools and their arguments, as a log record names them.
+ARGUMENTS = {"craft": ("ingredients", "target"), "get_info": ("items",), "view_inventory": (), "finish": ("message",)}
+READ_ONLY = frozenset({"get_info", "view_inventory"})  # tools that change nothing
+COMMANDS = {
+    "craft": "craft",
+    "info": "get_info",
+    "get_info": "get_info",
+    "inventory": "view_inventory",
+    "view_inventory": "view_inventory",
+    "finish": "finish",
+}
+_CLOEXEC = getattr(os, "O_CLOEXEC", 0)
+
+USAGE = """\
+usage: textcraft COMMAND [ARGUMENTS]
+
+Play the TextCraft task in $TEXTCRAFT_DIR (default /app/textcraft, the game's directory).
+
+  textcraft craft TARGET COUNT INGREDIENT=N [INGREDIENT=N ...]
+      Craft COUNT of TARGET from exactly these ingredients.  COUNT must be divisible by the recipe's
+      result_count; each ingredient's N is its recipe count times COUNT / result_count.
+      Example: textcraft craft m2_i2 2 m0_i1=2 m1_i1=1
+  textcraft info ITEM [ITEM ...]
+      Recipe information for the items, as a JSON list.
+  textcraft inventory
+      Your current inventory, as JSON {item_name: count}.
+  textcraft finish MESSAGE
+      Complete the task with a message saying what you achieved.  The task is graded on what your
+      inventory gained; no command is accepted after it.
+
+craft --json '{"ingredients": {...}, "target": [item, count]}' and info --json '[item, ...]' take the
+arguments as JSON.  get_info and view_inventory are other names for info and inventory.
+"""
+
+
+# ---------------------------------------------------------------------------------------------------- the world
+
+
+class Recipe:
+    __slots__ = ("result_count", "ingredients")
+
+    def __init__(self, result_count, ingredients):
+        self.result_count = result_count
+        self.ingredients = ingredients  # {item or "tag:<name>": count}, in the recipe's order
+
+
+class RecipeBook:
+    """A world's recipes (``recipes.json``), with the lookups of platoon's recipe databases.
+
+    The file lists each craftable item's recipes (ingredients as ``[name, count]`` pairs, in order), the base items,
+    every item's crafting depth (0 for items it does not list) and the items each ``tag:<name>`` ingredient accepts.
+    """
+
+    def __init__(self, data, sha256=None):
+        if not isinstance(data, dict) or data.get("format") != RECIPES_FORMAT:
+            raise ValueError("not a %s file" % RECIPES_FORMAT)
+        self.name = data["name"]
+        self.sha256 = sha256
+        self.recipes = {
+            item: [
+                Recipe(recipe["result_count"], {name: count for name, count in recipe["ingredients"]})
+                for recipe in recipes
+            ]
+            for item, recipes in data["recipes"].items()
+        }
+        self.base_items = frozenset(data["base_items"])
+        self.depths = dict(data["depths"])
+        self.tags = {tag: list(items) for tag, items in data["tags"].items()}
+
+    @classmethod
+    def load(cls, path):
+        with open(path, "rb") as handle:
+            raw = handle.read()
+        return cls(json.loads(raw.decode("utf-8")), sha256=hashlib.sha256(raw).hexdigest())
+
+    def get_recipes_for_item(self, item):
+        return self.recipes.get(item, [])
+
+    def can_craft(self, item):
+        return item in self.recipes
+
+    def is_base_item(self, item):
+        return item in self.base_items
+
+    def get_crafting_depth(self, item):
+        return self.depths.get(item, 0)
+
+    def get_items_for_tag(self, tag):
+        return list(self.tags.get(tag, []))
+
+
+def load_task(path):
+    """A task file (``task.json``): its goal, targets and starting inventory, and its recipes' SHA-256."""
+
+    with open(path, "rb") as handle:
+        task = json.loads(handle.read().decode("utf-8"))
+    if not isinstance(task, dict) or task.get("format") != TASK_FORMAT:
+        raise ValueError("%s is not a %s file" % (path, TASK_FORMAT))
+    for key in ("name", "goal", "target_items", "initial_inventory", "recipes_sha256"):
+        if key not in task:
+            raise ValueError("%s has no %r" % (path, key))
+    return task
+
+
+# ---------------------------------------------------------------------------------------------------- the game
+
+
+class Game:
+    """One episode: platoon's ``TextCraftEnvironment`` tools over an inventory, its rules and messages unchanged."""
+
+    def __init__(self, book, task):
+        self.book = book
+        self.goal = task["goal"]
+        self.target_items = dict(task["target_items"])
+        self.inventory = dict(task["initial_inventory"])
+        self.initial_inventory = dict(self.inventory)
+        self.finished = False
+        self.score = 0.0
+        self.reward_misc = {}
+        self.crafts = 0  # successful crafts
+
+    def call(self, tool, args):
+        """Run a tool with its arguments (the JSON values a tool call carries); the observation text it returns."""
+
+        if tool == "craft":
+            text = self.craft(args["ingredients"], args["target"])
+            self.crafts += text.startswith(CRAFTED)
+            return text
+        if tool == "get_info":
+            return json.dumps(self.get_info(args["items"]))
+        if tool == "view_inventory":
+            return json.dumps(dict(self.inventory))
+        if tool == "finish":
+            self.score, self.reward_misc = self.evaluate(args["message"])
+            self.finished = True
+            return args["message"]
+        raise ValueError("unknown tool %r" % (tool,))
+
+    def craft(self, ingredients, target):
+        """``TextCraftEnvironment._craft``: the same checks in the same order, with the same messages."""
+
+        if not isinstance(ingredients, dict):
+            return f"Error: ingredients must be a dict, got {type(ingredients).__name__}"
+        if not isinstance(target, (tuple, list)) or len(target) != 2:
+            return "Error: target must be a tuple of (item_name, count)"
+        target_item, target_count = target
+        if not isinstance(target_item, str):
+            return f"Error: target item must be a string, got {type(target_item).__name__}"
+        if not isinstance(target_count, int):
+            return f"Error: target count must be an int, got {type(target_count).__name__}"
+        if target_count <= 0:
+            return f"Error: target count must be positive, got {target_count}"
+        for ing_item, ing_count in ingredients.items():
+            if not isinstance(ing_item, str):
+                return f"Error: ingredient name must be a string, got {type(ing_item).__name__}"
+            if not isinstance(ing_count, int):
+                return f"Error: ingredient count for {ing_item} must be an int, got {type(ing_count).__name__}"
+            if ing_count <= 0:
+                return f"Error: ingredient count for {ing_item} must be positive, got {ing_count}"
+
+        book = self.book
+        recipes = book.get_recipes_for_item(target_item)
+        if not recipes:
+            return f"Error: No recipe found for {target_item}"
+
+        errors = []
+        for recipe_idx, recipe in enumerate(recipes):
+            if target_count % recipe.result_count != 0:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Target count {target_count} is not divisible "
+                    f"by recipe result count {recipe.result_count}"
+                )
+                continue
+            num_crafts = target_count // recipe.result_count
+
+            ingredient_mapping = {}  # recipe ingredient (or tag) -> provided item
+            recipe_error = None
+            for recipe_ing, recipe_count in recipe.ingredients.items():
+                total_required = recipe_count * num_crafts
+                if recipe_ing.startswith("tag:"):
+                    satisfying_items = book.get_items_for_tag(recipe_ing.replace("tag:", ""))
+                    provided = next(
+                        (
+                            item
+                            for item, count in ingredients.items()
+                            if item in satisfying_items and count == total_required
+                        ),
+                        None,
+                    )
+                    if provided is None:
+                        recipe_error = f"No ingredient provided for {recipe_ing}. Expected one of: {satisfying_items}"
+                        break
+                    ingredient_mapping[recipe_ing] = provided
+                else:
+                    if recipe_ing not in ingredients:
+                        recipe_error = f"Missing required ingredient {recipe_ing}"
+                        break
+                    if ingredients[recipe_ing] != total_required:
+                        recipe_error = (
+                            f"Wrong amount of {recipe_ing}. Need {total_required}, provided {ingredients[recipe_ing]}"
+                        )
+                        break
+                    ingredient_mapping[recipe_ing] = recipe_ing
+            if recipe_error:
+                errors.append(f"Recipe {recipe_idx + 1}: {recipe_error}")
+                continue
+
+            extra_ingredients = [item for item in ingredients if item not in ingredient_mapping.values()]
+            if extra_ingredients:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Extra ingredients not required: {', '.join(extra_ingredients)}"
+                )
+                continue
+
+            missing = []
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                required = recipe.ingredients[recipe_ing] * num_crafts
+                available = self.inventory.get(provided_ing, 0)
+                if available < required:
+                    missing.append(f"{provided_ing}: need {required}, have {available}")
+            if missing:
+                errors.append(f"Recipe {recipe_idx + 1}: Insufficient ingredients in inventory: {', '.join(missing)}")
+                continue
+
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                self.inventory[provided_ing] -= recipe.ingredients[recipe_ing] * num_crafts
+                if self.inventory[provided_ing] <= 0:
+                    del self.inventory[provided_ing]
+            crafted_count = recipe.result_count * num_crafts
+            self.inventory[target_item] = self.inventory.get(target_item, 0) + crafted_count
+            return f"Successfully crafted {crafted_count} {target_item}(s)"
+
+        return f"Error: All {len(recipes)} recipe(s) failed for {target_item}. Errors:\n" + "\n".join(errors)
+
+    def get_info(self, items):
+        """``TextCraftEnvironment._get_info``."""
+
+        book = self.book
+        results = []
+        for item in items:
+            info = {
+                "item": item,
+                "can_craft": book.can_craft(item),
+                "is_base": book.is_base_item(item),
+                "in_inventory": self.inventory.get(item, 0),
+                "crafting_depth": book.get_crafting_depth(item),
+                "recipes": [],
+            }
+            if info["can_craft"]:
+                for recipe in book.get_recipes_for_item(item):
+                    expanded = {}
+                    for ing, count in recipe.ingredients.items():
+                        if ing.startswith("tag:"):
+                            expanded[ing] = {"count": count, "use_one_of": book.get_items_for_tag(ing[4:])}
+                        else:
+                            expanded[ing] = count
+                    info["recipes"].append({"ingredients": expanded, "result_count": recipe.result_count})
+            results.append(info)
+        return results
+
+    def evaluate(self, finish_message):
+        """``TextCraftEnvironment.evaluate``: success when the inventory gained every target count and the finish
+        message is not empty."""
+
+        reward_misc = {}
+        score = 0.0
+        if finish_message:
+            if not self.target_items:
+                return 0.0, {"success": False, "error": "No target items defined in task", "reward/success": 0.0}
+            missing = {
+                item: required - (self.inventory.get(item, 0) - self.initial_inventory.get(item, 0))
+                for item, required in self.target_items.items()
+                if self.inventory.get(item, 0) - self.initial_inventory.get(item, 0) < required
+            }
+            reward_misc["success"] = not missing
+            if missing:
+                reward_misc["missing_items"] = missing
+            else:
+                score = 1.0
+            reward_misc["target_items"] = dict(self.target_items)
+            reward_misc["initial_inventory"] = dict(self.initial_inventory)
+            reward_misc["final_inventory"] = dict(self.inventory)
+        else:
+            reward_misc["success"] = False
+            reward_misc["error"] = "Episode ended without calling finish() - likely timeout or max steps reached"
+        reward_misc["reward/success"] = score
+        return score, reward_misc
+
+
+# ---------------------------------------------------------------------------------------------------- the log
+
+
+class LogError(ValueError):
+    """An action log the game could not have written: its replay stops there."""
+
+
+def _unique_pairs(pairs):
+    found = {}
+    for key, value in pairs:
+        if key in found:
+            raise ValueError("duplicate key %r" % (key,))
+        found[key] = value
+    return found
+
+
+def _no_constant(name):
+    raise ValueError("%s is not a JSON number" % name)
+
+
+def _finite_float(text):
+    value = float(text)
+    if value != value or value in (float("inf"), float("-inf")):
+        raise ValueError("%s is out of range" % text)
+    return value
+
+
+def parse_json(text):
+    """Strict JSON: no duplicate keys, no NaN or Infinity (also none that overflows, such as 1e999), so every value
+    it returns can be written back to the log."""
+
+    return json.loads(text, object_pairs_hook=_unique_pairs, parse_constant=_no_constant, parse_float=_finite_float)
+
+
+def encode_record(seq, tool, args, ok=None):
+    """A log line: ``{"seq", "tool", "args"}``, plus ``"ok"`` (the craft succeeded) for a craft."""
+
+    record = {"seq": seq, "tool": tool, "args": args}
+    if tool == "craft":
+        record["ok"] = bool(ok)
+    return (json.dumps(record, ensure_ascii=True, separators=(",", ":"), allow_nan=False) + "\n").encode("ascii")
+
+
+def check_arguments(tool, args):
+    """``args`` as a log record or a command may give them to ``tool``; ValueError says what is wrong."""
+
+    if not isinstance(args, dict) or sorted(args) != sorted(ARGUMENTS[tool]):
+        raise ValueError("%s takes the arguments %s" % (tool, ", ".join(ARGUMENTS[tool]) or "none"))
+    if tool == "get_info" and (
+        not isinstance(args["items"], list) or not all(isinstance(item, str) for item in args["items"])
+    ):
+        raise ValueError("get_info takes a list of item names")
+    if tool == "finish" and not isinstance(args["message"], str):
+        raise ValueError("finish takes a message string")
+
+
+def _record(line, seq):
+    try:
+        record = parse_json(line.decode("utf-8"))
+    except (UnicodeDecodeError, ValueError, RecursionError) as exc:
+        raise LogError("record %d is not a JSON object: %s" % (seq, exc)) from None
+    if not isinstance(record, dict):
+        raise LogError("record %d is not a JSON object" % seq)
+    tool = record.get("tool")
+    if not isinstance(tool, str) or tool not in ARGUMENTS:
+        raise LogError("record %d names no tool of the game: %r" % (seq, tool))
+    keys = {"seq", "tool", "args", "ok"} if tool == "craft" else {"seq", "tool", "args"}
+    if set(record) != keys:
+        raise LogError("record %d must have exactly the keys %s" % (seq, sorted(keys)))
+    if type(record["seq"]) is not int or record["seq"] != seq:
+        raise LogError("record %d is numbered %r" % (seq, record["seq"]))
+    try:
+        check_arguments(tool, record["args"])
+    except ValueError as exc:
+        raise LogError("record %d: %s" % (seq, exc)) from None
+    if tool == "craft" and not isinstance(record["ok"], bool):
+        raise LogError("record %d: ok must be true or false" % seq)
+    return tool, record["args"], record.get("ok")
+
+
+def replay(game, data):
+    """Apply a log's records to ``game``; how many there were.  LogError at the first record the game could not
+    have written: the replay stops there.
+
+    The records are read one at a time, and those of ``get_info`` and ``view_inventory``, which change nothing, have
+    their arguments checked but their output never rebuilt, so replaying any log within the size cap takes seconds
+    and a bounded amount of memory (a ``get_info`` record can name millions of items)."""
+
+    if not data:
+        return 0
+    if not data.endswith(b"\n"):
+        raise LogError("the last record does not end with a newline")
+    seq = start = 0
+    while start < len(data):
+        end = data.index(b"\n", start)
+        seq += 1
+        if game.finished:
+            raise LogError("record %d follows finish" % seq)
+        tool, args, ok = _record(data[start:end], seq)
+        start = end + 1
+        if tool in READ_ONLY:
+            continue
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:  # arguments no command writes
+            raise LogError("record %d cannot be applied: %s: %s" % (seq, type(exc).__name__, exc)) from None
+        if tool == "craft" and text.startswith(CRAFTED) != ok:
+            claim = "succeeded" if ok else "failed"
+            raise LogError("record %d says the craft %s, but the rules give: %s" % (seq, claim, text))
+    return seq
+
+
+# ---------------------------------------------------------------------------------------------------- the command
+
+
+class UsageError(ValueError):
+    pass
+
+
+class Result:
+    """What a command printed and its exit status: 0 done, 1 a game error (a rejected craft, the episode is over),
+    2 a usage error (nothing was run or logged), 3 the task cannot be played."""
+
+    def __init__(self, code, out="", err=""):
+        self.code = code
+        self.out = out
+        self.err = err
+
+
+def parse_command(argv):
+    """``(tool, args)`` of a command line; UsageError when it is not one."""
+
+    if not argv:
+        raise UsageError("no command")
+    tool = COMMANDS.get(argv[0])
+    if tool is None:
+        raise UsageError("unknown command %r" % argv[0])
+    rest = argv[1:]
+    if tool == "craft":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("craft --json takes one JSON object")
+            args = _json_argument(rest[1])
+            if not isinstance(args, dict) or sorted(args) != ["ingredients", "target"]:
+                raise UsageError('craft --json takes {"ingredients": {...}, "target": [item, count]}')
+            return tool, args
+        if len(rest) < 2:
+            raise UsageError("craft takes TARGET COUNT INGREDIENT=N ...")
+        ingredients = {}
+        for word in rest[2:]:
+            name, sep, count = word.rpartition("=")
+            if not sep or not name:
+                raise UsageError("ingredients are INGREDIENT=N, got %r" % word)
+            if name in ingredients:
+                raise UsageError("ingredient %r is given twice" % name)
+            ingredients[name] = _integer(count, "the count of %s" % name)
+        return tool, {"ingredients": ingredients, "target": [rest[0], _integer(rest[1], "COUNT")]}
+    if tool == "get_info":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("info --json takes one JSON list")
+            items = _json_argument(rest[1])
+        else:
+            items = list(rest)
+        args = {"items": items}
+    elif tool == "view_inventory":
+        if rest:
+            raise UsageError("inventory takes no arguments")
+        args = {}
+    else:
+        if not rest:
+            raise UsageError("finish takes a MESSAGE saying what you achieved")
+        args = {"message": " ".join(rest)}
+    try:
+        check_arguments(tool, args)
+    except ValueError as exc:
+        raise UsageError(str(exc)) from None
+    return tool, args
+
+
+def _json_argument(text):
+    try:
+        return parse_json(text)
+    except (ValueError, RecursionError) as exc:
+        raise UsageError("not valid JSON: %s" % exc) from None
+
+
+def _integer(text, what):
+    try:
+        return int(text)
+    except ValueError:
+        raise UsageError("%s must be an integer, got %r" % (what, text)) from None
+
+
+def default_directory():
+    return os.environ.get("TEXTCRAFT_DIR") or os.path.dirname(os.path.abspath(__file__))
+
+
+def run(argv, directory=None, recipes=None):
+    """Run a command line against the task in ``directory`` (default ``$TEXTCRAFT_DIR``, else this file's
+    directory), with the recipes ``recipes`` (default ``$TEXTCRAFT_RECIPES``, else the directory's
+    ``recipes.json``)."""
+
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        return Result(0 if argv else 2, USAGE)
+    if argv[0] == "--version":
+        return Result(0, "textcraft %s" % VERSION)
+    try:
+        tool, args = parse_command(argv)
+    except UsageError as exc:
+        return Result(2, err="textcraft: %s\n\n%s" % (exc, USAGE))
+    directory = directory or default_directory()
+    try:
+        task = load_task(os.path.join(directory, TASK_FILE))
+        book = RecipeBook.load(recipes or os.environ.get("TEXTCRAFT_RECIPES") or os.path.join(directory, RECIPES_FILE))
+    except (OSError, ValueError, KeyError) as exc:
+        return Result(3, err="textcraft: cannot load the task: %s" % exc)
+    if task["recipes_sha256"] != book.sha256:
+        return Result(3, err="textcraft: the recipes (%s) are not the ones of this task" % book.sha256)
+    path = os.path.join(directory, LOG_FILE)
+    try:
+        fd = os.open(path, os.O_RDWR | os.O_CREAT | os.O_APPEND | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    except OSError as exc:
+        why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+        return Result(3, err="textcraft: cannot open the action log %s: %s" % (path, why))
+    try:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_EX)
+        except OSError:
+            pass  # a file system without locks: commands are not expected to overlap
+        if not stat.S_ISREG(os.fstat(fd).st_mode):
+            return Result(3, err="textcraft: the action log %s is not a regular file" % path)
+        data = _read_all(fd)
+        game = Game(book, task)
+        try:
+            seq = replay(game, data) + 1
+        except LogError as exc:
+            return Result(
+                3, err="textcraft: the action log %s does not replay (%s); the episode cannot continue" % (path, exc)
+            )
+        if game.finished:
+            return Result(
+                1, "Error: the episode is finished (textcraft finish was called); no command is accepted after it"
+            )
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:
+            return Result(2, err="textcraft: cannot run %s: %s: %s" % (tool, type(exc).__name__, exc))
+        ok = text.startswith(CRAFTED)
+        line = encode_record(seq, tool, args, ok)
+        if len(data) + len(line) > LOG_CAP_BYTES:
+            return Result(1, "Error: the action log is full (%d bytes); no command is accepted" % LOG_CAP_BYTES)
+        _write_all(fd, line)
+    finally:
+        os.close(fd)
+    return Result(1 if tool == "craft" and not ok else 0, text)
+
+
+def _read_all(fd):
+    os.lseek(fd, 0, os.SEEK_SET)
+    chunks = []
+    while True:
+        chunk = os.read(fd, 1 << 20)
+        if not chunk:
+            return b"".join(chunks)
+        chunks.append(chunk)
+
+
+def _write_all(fd, data):
+    view = memoryview(data)
+    while view:
+        view = view[os.write(fd, view) :]
+
+
+# ---------------------------------------------------------------------------------------------------- the verifier
+
+
+def read_untrusted(root, relative, cap=LOG_CAP_BYTES):
+    """The bytes of ``root/relative``, reached without following a symbolic link below ``root``; None when it does
+    not exist.  LogError when it is not a regular file, or holds more than ``cap`` bytes."""
+
+    parts = [part for part in relative.split("/") if part not in ("", ".")]
+    if not parts or ".." in parts:
+        raise ValueError("%r is not a path below the root" % relative)
+    directory = os.open(root, os.O_RDONLY | os.O_DIRECTORY | _CLOEXEC)
+    try:
+        for part in parts[:-1]:
+            try:
+                below = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW | _CLOEXEC, dir_fd=directory)
+            except FileNotFoundError:
+                return None
+            except OSError as exc:
+                raise LogError("%s on the way to the action log is not a directory (%s)" % (part, exc.strerror))
+            os.close(directory)
+            directory = below
+        try:
+            fd = os.open(parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK | _CLOEXEC, dir_fd=directory)
+        except FileNotFoundError:
+            return None
+        except OSError as exc:
+            why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+            raise LogError("cannot open the action log: %s" % why)
+    finally:
+        os.close(directory)
+    try:
+        info = os.fstat(fd)
+        if not stat.S_ISREG(info.st_mode):
+            raise LogError("the action log is not a regular file")
+        if info.st_size > cap:
+            raise LogError("the action log holds %d bytes; the limit is %d" % (info.st_size, cap))
+        chunks, total = [], 0
+        while total <= cap:
+            chunk = os.read(fd, min(1 << 20, cap + 1 - total))
+            if not chunk:
+                break
+            chunks.append(chunk)
+            total += len(chunk)
+        if total > cap:
+            raise LogError("the action log holds more than %d bytes" % cap)
+        return b"".join(chunks)
+    finally:
+        os.close(fd)
+
+
+def verify(task_path, recipes_path, root, log, out=None):
+    """Grade the log at ``root/log`` against the trusted task and recipes; the verdict (``reward`` and why).
+    Writes ``reward.json`` and ``textcraft-verdict.json`` into ``out`` when given."""
+
+    task = load_task(task_path)
+    book = RecipeBook.load(recipes_path)
+    if task["recipes_sha256"] != book.sha256:
+        raise ValueError("the verifier's recipes %s are not the task's %s" % (book.sha256, task["recipes_sha256"]))
+    game = Game(book, task)
+    verdict = {"reward": 0.0, "task": task["name"], "version": VERSION, "records": 0, "crafts": 0, "finished": False}
+    try:
+        data = read_untrusted(root, log)
+        if data is None:
+            verdict["reason"] = "no action log: no textcraft command ran"
+        else:
+            verdict["log_bytes"] = len(data)
+            verdict["records"] = replay(game, data)
+            verdict["crafts"] = game.crafts
+            verdict["finished"] = game.finished
+            if not game.finished:
+                verdict["reason"] = "the episode did not end with textcraft finish"
+            elif game.score >= 1.0:
+                verdict["reward"] = 1.0
+                verdict["reason"] = "finished with every target crafted"
+            elif game.reward_misc.get("missing_items"):
+                verdict["reason"] = "finished without every target crafted"
+                verdict["missing_items"] = game.reward_misc["missing_items"]
+            else:
+                verdict["reason"] = "finished with an empty message"
+    except LogError as exc:
+        verdict["reason"] = "the action log is not one the game wrote: %s" % exc
+    if out is not None:
+        _write_new(out, VERDICT_FILE, json.dumps(verdict, indent=1, sort_keys=True) + "\n")
+        _write_new(out, REWARD_FILE, json.dumps({"reward": verdict["reward"]}) + "\n")
+    return verdict
+
+
+def _write_new(directory, name, text):
+    """Write ``directory/name`` through a new file and a rename, so the name ends up a regular file whatever was
+    there."""
+
+    temporary = os.path.join(directory, ".%s.%d.tmp" % (name, os.getpid()))
+    fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    try:
+        _write_all(fd, text.encode("utf-8"))
+        os.fsync(fd)
+    finally:
+        os.close(fd)
+    os.replace(temporary, os.path.join(directory, name))
+
+
+def verify_main(argv):
+    parser = argparse.ArgumentParser(prog="textcraft_game.py verify", description="Grade a TextCraft action log.")
+    parser.add_argument("--task", required=True, help="the trusted task.json")
+    parser.add_argument("--recipes", required=True, help="the trusted recipes.json")
+    parser.add_argument("--root", required=True, help="the sandbox root the log path is below")
+    parser.add_argument("--log", required=True, help="the log's path below the root")
+    parser.add_argument("--out", required=True, help="the verifier's output directory (reward.json)")
+    options = parser.parse_args(argv)
+    try:
+        verdict = verify(options.task, options.recipes, options.root, options.log, options.out)
+    except (OSError, ValueError, KeyError) as exc:
+        print("textcraft verify: cannot grade: %s" % exc, file=sys.stderr)
+        return 1
+    print(
+        "reward %g: %s (%d records, %d crafts)"
+        % (verdict["reward"], verdict["reason"], verdict["records"], verdict["crafts"])
+    )
+    return 0
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv[:1] == ["verify"]:
+        return verify_main(argv[1:])
+    result = run(argv)
+    if result.out:
+        print(result.out)
+    if result.err:
+        print(result.err, file=sys.stderr)
+    return result.code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/textcraft-synth-train-easy-00604/environment/Dockerfile

@@ -0,0 +1,17 @@
+# textcraft-synth-train-easy-00604: task.json sha256:4106a4385ee832fa7bf9462de7c0e9623ed32581e908cf603ed669be276d99be
+FROM docker.io/library/python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1
+# The image is the same for every task (and for the verifier): Python, tmux for terminal agents, and the
+# `textcraft` command, which runs the game file below.
+RUN set -eux; \
+    printf '#!/bin/sh\nexec python3 -I /app/textcraft/textcraft_game.py "$@"\n' \
+        > /usr/local/bin/textcraft; \
+    chmod 0755 /usr/local/bin/textcraft; \
+    apt-get -o APT::Sandbox::User=root update; \
+    apt-get -o APT::Sandbox::User=root install -y --no-install-recommends tmux; \
+    rm -rf /var/lib/apt/lists/*
+# The game and the world's recipes (the same in every task), then this task's goal and starting inventory.  The
+# game keeps its action log next to them.
+WORKDIR /app
+ENV TEXTCRAFT_DIR=/app/textcraft
+COPY textcraft_game.py recipes.json /app/textcraft/
+COPY task.json /app/textcraft/

tasks/textcraft-synth-train-easy-00604/environment/task.json

@@ -0,0 +1,18 @@
+{
+ "format": "textcraft-task/1",
+ "name": "textcraft-synth-train-easy-00604",
+ "world": "textcraft-synth",
+ "goal": "Craft the following items: 1x t8_i3",
+ "target_items": {
+  "t8_i3": 1
+ },
+ "initial_inventory": {
+  "raw_t8": 2,
+  "raw_t9": 1,
+  "raw_t0": 2,
+  "raw_o8": 3,
+  "raw_o4": 1,
+  "m9_ore": 4
+ },
+ "recipes_sha256": "a020eec273337c66b35c0fc487664e35c44da65ad18e9afffe6a4c25af949f10"
+}

tasks/textcraft-synth-train-easy-00604/environment/textcraft_game.py

@@ -0,0 +1,756 @@
+"""TextCraft in a container: the ``textcraft`` command of a Harbor task, and the verifier that grades it.
+
+This one file is the whole game.  It needs Python 3.8 or later and its standard library only, and it never imports
+platoon: the exporter (``python -m platoon.textcraft.harbor export``) copies it into every task as
+``textcraft_game.py``, into ``environment/`` (the container gets it at ``/app/textcraft/textcraft_game.py``, which
+the image's ``textcraft`` command runs) and into ``tests/`` for the verifier.  It reproduces platoon's TextCraft
+environments (``platoon.textcraft.env``): the same four tools with the same arguments, the same observation text
+and the same success rule.
+
+=========================================  ===================  ===============================================
+command                                    environment tool     prints
+=========================================  ===================  ===============================================
+``textcraft craft TARGET COUNT ING=N ...``  ``craft``            ``Successfully crafted ...`` or ``Error: ...``
+``textcraft info ITEM ...``                 ``get_info``         the recipe information, as JSON
+``textcraft inventory``                     ``view_inventory``   the inventory, as JSON
+``textcraft finish MESSAGE``                ``finish``           the message; the episode ends
+=========================================  ===================  ===============================================
+
+``craft --json '{"ingredients": {...}, "target": [item, count]}'`` and ``info --json '[item, ...]'`` take a tool's
+arguments as JSON values, the way a tool call passes them.
+
+**State.**  ``$TEXTCRAFT_DIR`` (default: this file's directory, ``/app/textcraft`` in a task's container) holds the
+task (``task.json``: goal, targets, starting inventory), the world's recipes (``recipes.json``, or
+``$TEXTCRAFT_RECIPES``) and the action log (``actions.jsonl``).  The log is the state: under an exclusive lock,
+every command replays the log from the starting inventory, runs, and appends its own record (``{"seq", "tool",
+"args"}``, plus ``"ok"`` for a craft).  Nothing is accepted after ``finish``, or once the log no longer replays.
+
+**Grading** (``python3 textcraft_game.py verify``, from the task's ``tests/test.sh``) replays the log with trusted
+copies of the task and the recipes.  The reward is 1 when the log is an episode the rules allow that ends in
+``finish`` with a message, and the inventory then holds every target count on top of the starting inventory (the
+environment's rule); otherwise it is 0.  The log must be a regular file of at most 32 MiB, reached without a
+symbolic link below the sandbox root.  A record that does not parse, breaks the record format or the numbering,
+follows ``finish``, or claims a craft outcome the rules do not give ends the replay with reward 0: only a log the
+command could have written earns a reward.  A craft the rules reject, recorded as rejected, changes nothing, as in
+the environment.
+"""
+
+from __future__ import annotations
+
+import argparse
+import errno
+import fcntl
+import hashlib
+import json
+import os
+import stat
+import sys
+
+VERSION = "1.0"
+TASK_FORMAT = "textcraft-task/1"
+RECIPES_FORMAT = "textcraft-recipes/1"
+TASK_FILE = "task.json"
+LOG_FILE = "actions.jsonl"
+RECIPES_FILE = "recipes.json"
+REWARD_FILE = "reward.json"
+VERDICT_FILE = "textcraft-verdict.json"
+LOG_CAP_BYTES = 32 * 1024 * 1024
+CRAFTED = "Successfully crafted"
+# The environment's tools and their arguments, as a log record names them.
+ARGUMENTS = {"craft": ("ingredients", "target"), "get_info": ("items",), "view_inventory": (), "finish": ("message",)}
+READ_ONLY = frozenset({"get_info", "view_inventory"})  # tools that change nothing
+COMMANDS = {
+    "craft": "craft",
+    "info": "get_info",
+    "get_info": "get_info",
+    "inventory": "view_inventory",
+    "view_inventory": "view_inventory",
+    "finish": "finish",
+}
+_CLOEXEC = getattr(os, "O_CLOEXEC", 0)
+
+USAGE = """\
+usage: textcraft COMMAND [ARGUMENTS]
+
+Play the TextCraft task in $TEXTCRAFT_DIR (default /app/textcraft, the game's directory).
+
+  textcraft craft TARGET COUNT INGREDIENT=N [INGREDIENT=N ...]
+      Craft COUNT of TARGET from exactly these ingredients.  COUNT must be divisible by the recipe's
+      result_count; each ingredient's N is its recipe count times COUNT / result_count.
+      Example: textcraft craft m2_i2 2 m0_i1=2 m1_i1=1
+  textcraft info ITEM [ITEM ...]
+      Recipe information for the items, as a JSON list.
+  textcraft inventory
+      Your current inventory, as JSON {item_name: count}.
+  textcraft finish MESSAGE
+      Complete the task with a message saying what you achieved.  The task is graded on what your
+      inventory gained; no command is accepted after it.
+
+craft --json '{"ingredients": {...}, "target": [item, count]}' and info --json '[item, ...]' take the
+arguments as JSON.  get_info and view_inventory are other names for info and inventory.
+"""
+
+
+# ---------------------------------------------------------------------------------------------------- the world
+
+
+class Recipe:
+    __slots__ = ("result_count", "ingredients")
+
+    def __init__(self, result_count, ingredients):
+        self.result_count = result_count
+        self.ingredients = ingredients  # {item or "tag:<name>": count}, in the recipe's order
+
+
+class RecipeBook:
+    """A world's recipes (``recipes.json``), with the lookups of platoon's recipe databases.
+
+    The file lists each craftable item's recipes (ingredients as ``[name, count]`` pairs, in order), the base items,
+    every item's crafting depth (0 for items it does not list) and the items each ``tag:<name>`` ingredient accepts.
+    """
+
+    def __init__(self, data, sha256=None):
+        if not isinstance(data, dict) or data.get("format") != RECIPES_FORMAT:
+            raise ValueError("not a %s file" % RECIPES_FORMAT)
+        self.name = data["name"]
+        self.sha256 = sha256
+        self.recipes = {
+            item: [
+                Recipe(recipe["result_count"], {name: count for name, count in recipe["ingredients"]})
+                for recipe in recipes
+            ]
+            for item, recipes in data["recipes"].items()
+        }
+        self.base_items = frozenset(data["base_items"])
+        self.depths = dict(data["depths"])
+        self.tags = {tag: list(items) for tag, items in data["tags"].items()}
+
+    @classmethod
+    def load(cls, path):
+        with open(path, "rb") as handle:
+            raw = handle.read()
+        return cls(json.loads(raw.decode("utf-8")), sha256=hashlib.sha256(raw).hexdigest())
+
+    def get_recipes_for_item(self, item):
+        return self.recipes.get(item, [])
+
+    def can_craft(self, item):
+        return item in self.recipes
+
+    def is_base_item(self, item):
+        return item in self.base_items
+
+    def get_crafting_depth(self, item):
+        return self.depths.get(item, 0)
+
+    def get_items_for_tag(self, tag):
+        return list(self.tags.get(tag, []))
+
+
+def load_task(path):
+    """A task file (``task.json``): its goal, targets and starting inventory, and its recipes' SHA-256."""
+
+    with open(path, "rb") as handle:
+        task = json.loads(handle.read().decode("utf-8"))
+    if not isinstance(task, dict) or task.get("format") != TASK_FORMAT:
+        raise ValueError("%s is not a %s file" % (path, TASK_FORMAT))
+    for key in ("name", "goal", "target_items", "initial_inventory", "recipes_sha256"):
+        if key not in task:
+            raise ValueError("%s has no %r" % (path, key))
+    return task
+
+
+# ---------------------------------------------------------------------------------------------------- the game
+
+
+class Game:
+    """One episode: platoon's ``TextCraftEnvironment`` tools over an inventory, its rules and messages unchanged."""
+
+    def __init__(self, book, task):
+        self.book = book
+        self.goal = task["goal"]
+        self.target_items = dict(task["target_items"])
+        self.inventory = dict(task["initial_inventory"])
+        self.initial_inventory = dict(self.inventory)
+        self.finished = False
+        self.score = 0.0
+        self.reward_misc = {}
+        self.crafts = 0  # successful crafts
+
+    def call(self, tool, args):
+        """Run a tool with its arguments (the JSON values a tool call carries); the observation text it returns."""
+
+        if tool == "craft":
+            text = self.craft(args["ingredients"], args["target"])
+            self.crafts += text.startswith(CRAFTED)
+            return text
+        if tool == "get_info":
+            return json.dumps(self.get_info(args["items"]))
+        if tool == "view_inventory":
+            return json.dumps(dict(self.inventory))
+        if tool == "finish":
+            self.score, self.reward_misc = self.evaluate(args["message"])
+            self.finished = True
+            return args["message"]
+        raise ValueError("unknown tool %r" % (tool,))
+
+    def craft(self, ingredients, target):
+        """``TextCraftEnvironment._craft``: the same checks in the same order, with the same messages."""
+
+        if not isinstance(ingredients, dict):
+            return f"Error: ingredients must be a dict, got {type(ingredients).__name__}"
+        if not isinstance(target, (tuple, list)) or len(target) != 2:
+            return "Error: target must be a tuple of (item_name, count)"
+        target_item, target_count = target
+        if not isinstance(target_item, str):
+            return f"Error: target item must be a string, got {type(target_item).__name__}"
+        if not isinstance(target_count, int):
+            return f"Error: target count must be an int, got {type(target_count).__name__}"
+        if target_count <= 0:
+            return f"Error: target count must be positive, got {target_count}"
+        for ing_item, ing_count in ingredients.items():
+            if not isinstance(ing_item, str):
+                return f"Error: ingredient name must be a string, got {type(ing_item).__name__}"
+            if not isinstance(ing_count, int):
+                return f"Error: ingredient count for {ing_item} must be an int, got {type(ing_count).__name__}"
+            if ing_count <= 0:
+                return f"Error: ingredient count for {ing_item} must be positive, got {ing_count}"
+
+        book = self.book
+        recipes = book.get_recipes_for_item(target_item)
+        if not recipes:
+            return f"Error: No recipe found for {target_item}"
+
+        errors = []
+        for recipe_idx, recipe in enumerate(recipes):
+            if target_count % recipe.result_count != 0:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Target count {target_count} is not divisible "
+                    f"by recipe result count {recipe.result_count}"
+                )
+                continue
+            num_crafts = target_count // recipe.result_count
+
+            ingredient_mapping = {}  # recipe ingredient (or tag) -> provided item
+            recipe_error = None
+            for recipe_ing, recipe_count in recipe.ingredients.items():
+                total_required = recipe_count * num_crafts
+                if recipe_ing.startswith("tag:"):
+                    satisfying_items = book.get_items_for_tag(recipe_ing.replace("tag:", ""))
+                    provided = next(
+                        (
+                            item
+                            for item, count in ingredients.items()
+                            if item in satisfying_items and count == total_required
+                        ),
+                        None,
+                    )
+                    if provided is None:
+                        recipe_error = f"No ingredient provided for {recipe_ing}. Expected one of: {satisfying_items}"
+                        break
+                    ingredient_mapping[recipe_ing] = provided
+                else:
+                    if recipe_ing not in ingredients:
+                        recipe_error = f"Missing required ingredient {recipe_ing}"
+                        break
+                    if ingredients[recipe_ing] != total_required:
+                        recipe_error = (
+                            f"Wrong amount of {recipe_ing}. Need {total_required}, provided {ingredients[recipe_ing]}"
+                        )
+                        break
+                    ingredient_mapping[recipe_ing] = recipe_ing
+            if recipe_error:
+                errors.append(f"Recipe {recipe_idx + 1}: {recipe_error}")
+                continue
+
+            extra_ingredients = [item for item in ingredients if item not in ingredient_mapping.values()]
+            if extra_ingredients:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Extra ingredients not required: {', '.join(extra_ingredients)}"
+                )
+                continue
+
+            missing = []
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                required = recipe.ingredients[recipe_ing] * num_crafts
+                available = self.inventory.get(provided_ing, 0)
+                if available < required:
+                    missing.append(f"{provided_ing}: need {required}, have {available}")
+            if missing:
+                errors.append(f"Recipe {recipe_idx + 1}: Insufficient ingredients in inventory: {', '.join(missing)}")
+                continue
+
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                self.inventory[provided_ing] -= recipe.ingredients[recipe_ing] * num_crafts
+                if self.inventory[provided_ing] <= 0:
+                    del self.inventory[provided_ing]
+            crafted_count = recipe.result_count * num_crafts
+            self.inventory[target_item] = self.inventory.get(target_item, 0) + crafted_count
+            return f"Successfully crafted {crafted_count} {target_item}(s)"
+
+        return f"Error: All {len(recipes)} recipe(s) failed for {target_item}. Errors:\n" + "\n".join(errors)
+
+    def get_info(self, items):
+        """``TextCraftEnvironment._get_info``."""
+
+        book = self.book
+        results = []
+        for item in items:
+            info = {
+                "item": item,
+                "can_craft": book.can_craft(item),
+                "is_base": book.is_base_item(item),
+                "in_inventory": self.inventory.get(item, 0),
+                "crafting_depth": book.get_crafting_depth(item),
+                "recipes": [],
+            }
+            if info["can_craft"]:
+                for recipe in book.get_recipes_for_item(item):
+                    expanded = {}
+                    for ing, count in recipe.ingredients.items():
+                        if ing.startswith("tag:"):
+                            expanded[ing] = {"count": count, "use_one_of": book.get_items_for_tag(ing[4:])}
+                        else:
+                            expanded[ing] = count
+                    info["recipes"].append({"ingredients": expanded, "result_count": recipe.result_count})
+            results.append(info)
+        return results
+
+    def evaluate(self, finish_message):
+        """``TextCraftEnvironment.evaluate``: success when the inventory gained every target count and the finish
+        message is not empty."""
+
+        reward_misc = {}
+        score = 0.0
+        if finish_message:
+            if not self.target_items:
+                return 0.0, {"success": False, "error": "No target items defined in task", "reward/success": 0.0}
+            missing = {
+                item: required - (self.inventory.get(item, 0) - self.initial_inventory.get(item, 0))
+                for item, required in self.target_items.items()
+                if self.inventory.get(item, 0) - self.initial_inventory.get(item, 0) < required
+            }
+            reward_misc["success"] = not missing
+            if missing:
+                reward_misc["missing_items"] = missing
+            else:
+                score = 1.0
+            reward_misc["target_items"] = dict(self.target_items)
+            reward_misc["initial_inventory"] = dict(self.initial_inventory)
+            reward_misc["final_inventory"] = dict(self.inventory)
+        else:
+            reward_misc["success"] = False
+            reward_misc["error"] = "Episode ended without calling finish() - likely timeout or max steps reached"
+        reward_misc["reward/success"] = score
+        return score, reward_misc
+
+
+# ---------------------------------------------------------------------------------------------------- the log
+
+
+class LogError(ValueError):
+    """An action log the game could not have written: its replay stops there."""
+
+
+def _unique_pairs(pairs):
+    found = {}
+    for key, value in pairs:
+        if key in found:
+            raise ValueError("duplicate key %r" % (key,))
+        found[key] = value
+    return found
+
+
+def _no_constant(name):
+    raise ValueError("%s is not a JSON number" % name)
+
+
+def _finite_float(text):
+    value = float(text)
+    if value != value or value in (float("inf"), float("-inf")):
+        raise ValueError("%s is out of range" % text)
+    return value
+
+
+def parse_json(text):
+    """Strict JSON: no duplicate keys, no NaN or Infinity (also none that overflows, such as 1e999), so every value
+    it returns can be written back to the log."""
+
+    return json.loads(text, object_pairs_hook=_unique_pairs, parse_constant=_no_constant, parse_float=_finite_float)
+
+
+def encode_record(seq, tool, args, ok=None):
+    """A log line: ``{"seq", "tool", "args"}``, plus ``"ok"`` (the craft succeeded) for a craft."""
+
+    record = {"seq": seq, "tool": tool, "args": args}
+    if tool == "craft":
+        record["ok"] = bool(ok)
+    return (json.dumps(record, ensure_ascii=True, separators=(",", ":"), allow_nan=False) + "\n").encode("ascii")
+
+
+def check_arguments(tool, args):
+    """``args`` as a log record or a command may give them to ``tool``; ValueError says what is wrong."""
+
+    if not isinstance(args, dict) or sorted(args) != sorted(ARGUMENTS[tool]):
+        raise ValueError("%s takes the arguments %s" % (tool, ", ".join(ARGUMENTS[tool]) or "none"))
+    if tool == "get_info" and (
+        not isinstance(args["items"], list) or not all(isinstance(item, str) for item in args["items"])
+    ):
+        raise ValueError("get_info takes a list of item names")
+    if tool == "finish" and not isinstance(args["message"], str):
+        raise ValueError("finish takes a message string")
+
+
+def _record(line, seq):
+    try:
+        record = parse_json(line.decode("utf-8"))
+    except (UnicodeDecodeError, ValueError, RecursionError) as exc:
+        raise LogError("record %d is not a JSON object: %s" % (seq, exc)) from None
+    if not isinstance(record, dict):
+        raise LogError("record %d is not a JSON object" % seq)
+    tool = record.get("tool")
+    if not isinstance(tool, str) or tool not in ARGUMENTS:
+        raise LogError("record %d names no tool of the game: %r" % (seq, tool))
+    keys = {"seq", "tool", "args", "ok"} if tool == "craft" else {"seq", "tool", "args"}
+    if set(record) != keys:
+        raise LogError("record %d must have exactly the keys %s" % (seq, sorted(keys)))
+    if type(record["seq"]) is not int or record["seq"] != seq:
+        raise LogError("record %d is numbered %r" % (seq, record["seq"]))
+    try:
+        check_arguments(tool, record["args"])
+    except ValueError as exc:
+        raise LogError("record %d: %s" % (seq, exc)) from None
+    if tool == "craft" and not isinstance(record["ok"], bool):
+        raise LogError("record %d: ok must be true or false" % seq)
+    return tool, record["args"], record.get("ok")
+
+
+def replay(game, data):
+    """Apply a log's records to ``game``; how many there were.  LogError at the first record the game could not
+    have written: the replay stops there.
+
+    The records are read one at a time, and those of ``get_info`` and ``view_inventory``, which change nothing, have
+    their arguments checked but their output never rebuilt, so replaying any log within the size cap takes seconds
+    and a bounded amount of memory (a ``get_info`` record can name millions of items)."""
+
+    if not data:
+        return 0
+    if not data.endswith(b"\n"):
+        raise LogError("the last record does not end with a newline")
+    seq = start = 0
+    while start < len(data):
+        end = data.index(b"\n", start)
+        seq += 1
+        if game.finished:
+            raise LogError("record %d follows finish" % seq)
+        tool, args, ok = _record(data[start:end], seq)
+        start = end + 1
+        if tool in READ_ONLY:
+            continue
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:  # arguments no command writes
+            raise LogError("record %d cannot be applied: %s: %s" % (seq, type(exc).__name__, exc)) from None
+        if tool == "craft" and text.startswith(CRAFTED) != ok:
+            claim = "succeeded" if ok else "failed"
+            raise LogError("record %d says the craft %s, but the rules give: %s" % (seq, claim, text))
+    return seq
+
+
+# ---------------------------------------------------------------------------------------------------- the command
+
+
+class UsageError(ValueError):
+    pass
+
+
+class Result:
+    """What a command printed and its exit status: 0 done, 1 a game error (a rejected craft, the episode is over),
+    2 a usage error (nothing was run or logged), 3 the task cannot be played."""
+
+    def __init__(self, code, out="", err=""):
+        self.code = code
+        self.out = out
+        self.err = err
+
+
+def parse_command(argv):
+    """``(tool, args)`` of a command line; UsageError when it is not one."""
+
+    if not argv:
+        raise UsageError("no command")
+    tool = COMMANDS.get(argv[0])
+    if tool is None:
+        raise UsageError("unknown command %r" % argv[0])
+    rest = argv[1:]
+    if tool == "craft":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("craft --json takes one JSON object")
+            args = _json_argument(rest[1])
+            if not isinstance(args, dict) or sorted(args) != ["ingredients", "target"]:
+                raise UsageError('craft --json takes {"ingredients": {...}, "target": [item, count]}')
+            return tool, args
+        if len(rest) < 2:
+            raise UsageError("craft takes TARGET COUNT INGREDIENT=N ...")
+        ingredients = {}
+        for word in rest[2:]:
+            name, sep, count = word.rpartition("=")
+            if not sep or not name:
+                raise UsageError("ingredients are INGREDIENT=N, got %r" % word)
+            if name in ingredients:
+                raise UsageError("ingredient %r is given twice" % name)
+            ingredients[name] = _integer(count, "the count of %s" % name)
+        return tool, {"ingredients": ingredients, "target": [rest[0], _integer(rest[1], "COUNT")]}
+    if tool == "get_info":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("info --json takes one JSON list")
+            items = _json_argument(rest[1])
+        else:
+            items = list(rest)
+        args = {"items": items}
+    elif tool == "view_inventory":
+        if rest:
+            raise UsageError("inventory takes no arguments")
+        args = {}
+    else:
+        if not rest:
+            raise UsageError("finish takes a MESSAGE saying what you achieved")
+        args = {"message": " ".join(rest)}
+    try:
+        check_arguments(tool, args)
+    except ValueError as exc:
+        raise UsageError(str(exc)) from None
+    return tool, args
+
+
+def _json_argument(text):
+    try:
+        return parse_json(text)
+    except (ValueError, RecursionError) as exc:
+        raise UsageError("not valid JSON: %s" % exc) from None
+
+
+def _integer(text, what):
+    try:
+        return int(text)
+    except ValueError:
+        raise UsageError("%s must be an integer, got %r" % (what, text)) from None
+
+
+def default_directory():
+    return os.environ.get("TEXTCRAFT_DIR") or os.path.dirname(os.path.abspath(__file__))
+
+
+def run(argv, directory=None, recipes=None):
+    """Run a command line against the task in ``directory`` (default ``$TEXTCRAFT_DIR``, else this file's
+    directory), with the recipes ``recipes`` (default ``$TEXTCRAFT_RECIPES``, else the directory's
+    ``recipes.json``)."""
+
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        return Result(0 if argv else 2, USAGE)
+    if argv[0] == "--version":
+        return Result(0, "textcraft %s" % VERSION)
+    try:
+        tool, args = parse_command(argv)
+    except UsageError as exc:
+        return Result(2, err="textcraft: %s\n\n%s" % (exc, USAGE))
+    directory = directory or default_directory()
+    try:
+        task = load_task(os.path.join(directory, TASK_FILE))
+        book = RecipeBook.load(recipes or os.environ.get("TEXTCRAFT_RECIPES") or os.path.join(directory, RECIPES_FILE))
+    except (OSError, ValueError, KeyError) as exc:
+        return Result(3, err="textcraft: cannot load the task: %s" % exc)
+    if task["recipes_sha256"] != book.sha256:
+        return Result(3, err="textcraft: the recipes (%s) are not the ones of this task" % book.sha256)
+    path = os.path.join(directory, LOG_FILE)
+    try:
+        fd = os.open(path, os.O_RDWR | os.O_CREAT | os.O_APPEND | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    except OSError as exc:
+        why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+        return Result(3, err="textcraft: cannot open the action log %s: %s" % (path, why))
+    try:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_EX)
+        except OSError:
+            pass  # a file system without locks: commands are not expected to overlap
+        if not stat.S_ISREG(os.fstat(fd).st_mode):
+            return Result(3, err="textcraft: the action log %s is not a regular file" % path)
+        data = _read_all(fd)
+        game = Game(book, task)
+        try:
+            seq = replay(game, data) + 1
+        except LogError as exc:
+            return Result(
+                3, err="textcraft: the action log %s does not replay (%s); the episode cannot continue" % (path, exc)
+            )
+        if game.finished:
+            return Result(
+                1, "Error: the episode is finished (textcraft finish was called); no command is accepted after it"
+            )
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:
+            return Result(2, err="textcraft: cannot run %s: %s: %s" % (tool, type(exc).__name__, exc))
+        ok = text.startswith(CRAFTED)
+        line = encode_record(seq, tool, args, ok)
+        if len(data) + len(line) > LOG_CAP_BYTES:
+            return Result(1, "Error: the action log is full (%d bytes); no command is accepted" % LOG_CAP_BYTES)
+        _write_all(fd, line)
+    finally:
+        os.close(fd)
+    return Result(1 if tool == "craft" and not ok else 0, text)
+
+
+def _read_all(fd):
+    os.lseek(fd, 0, os.SEEK_SET)
+    chunks = []
+    while True:
+        chunk = os.read(fd, 1 << 20)
+        if not chunk:
+            return b"".join(chunks)
+        chunks.append(chunk)
+
+
+def _write_all(fd, data):
+    view = memoryview(data)
+    while view:
+        view = view[os.write(fd, view) :]
+
+
+# ---------------------------------------------------------------------------------------------------- the verifier
+
+
+def read_untrusted(root, relative, cap=LOG_CAP_BYTES):
+    """The bytes of ``root/relative``, reached without following a symbolic link below ``root``; None when it does
+    not exist.  LogError when it is not a regular file, or holds more than ``cap`` bytes."""
+
+    parts = [part for part in relative.split("/") if part not in ("", ".")]
+    if not parts or ".." in parts:
+        raise ValueError("%r is not a path below the root" % relative)
+    directory = os.open(root, os.O_RDONLY | os.O_DIRECTORY | _CLOEXEC)
+    try:
+        for part in parts[:-1]:
+            try:
+                below = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW | _CLOEXEC, dir_fd=directory)
+            except FileNotFoundError:
+                return None
+            except OSError as exc:
+                raise LogError("%s on the way to the action log is not a directory (%s)" % (part, exc.strerror))
+            os.close(directory)
+            directory = below
+        try:
+            fd = os.open(parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK | _CLOEXEC, dir_fd=directory)
+        except FileNotFoundError:
+            return None
+        except OSError as exc:
+            why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+            raise LogError("cannot open the action log: %s" % why)
+    finally:
+        os.close(directory)
+    try:
+        info = os.fstat(fd)
+        if not stat.S_ISREG(info.st_mode):
+            raise LogError("the action log is not a regular file")
+        if info.st_size > cap:
+            raise LogError("the action log holds %d bytes; the limit is %d" % (info.st_size, cap))
+        chunks, total = [], 0
+        while total <= cap:
+            chunk = os.read(fd, min(1 << 20, cap + 1 - total))
+            if not chunk:
+                break
+            chunks.append(chunk)
+            total += len(chunk)
+        if total > cap:
+            raise LogError("the action log holds more than %d bytes" % cap)
+        return b"".join(chunks)
+    finally:
+        os.close(fd)
+
+
+def verify(task_path, recipes_path, root, log, out=None):
+    """Grade the log at ``root/log`` against the trusted task and recipes; the verdict (``reward`` and why).
+    Writes ``reward.json`` and ``textcraft-verdict.json`` into ``out`` when given."""
+
+    task = load_task(task_path)
+    book = RecipeBook.load(recipes_path)
+    if task["recipes_sha256"] != book.sha256:
+        raise ValueError("the verifier's recipes %s are not the task's %s" % (book.sha256, task["recipes_sha256"]))
+    game = Game(book, task)
+    verdict = {"reward": 0.0, "task": task["name"], "version": VERSION, "records": 0, "crafts": 0, "finished": False}
+    try:
+        data = read_untrusted(root, log)
+        if data is None:
+            verdict["reason"] = "no action log: no textcraft command ran"
+        else:
+            verdict["log_bytes"] = len(data)
+            verdict["records"] = replay(game, data)
+            verdict["crafts"] = game.crafts
+            verdict["finished"] = game.finished
+            if not game.finished:
+                verdict["reason"] = "the episode did not end with textcraft finish"
+            elif game.score >= 1.0:
+                verdict["reward"] = 1.0
+                verdict["reason"] = "finished with every target crafted"
+            elif game.reward_misc.get("missing_items"):
+                verdict["reason"] = "finished without every target crafted"
+                verdict["missing_items"] = game.reward_misc["missing_items"]
+            else:
+                verdict["reason"] = "finished with an empty message"
+    except LogError as exc:
+        verdict["reason"] = "the action log is not one the game wrote: %s" % exc
+    if out is not None:
+        _write_new(out, VERDICT_FILE, json.dumps(verdict, indent=1, sort_keys=True) + "\n")
+        _write_new(out, REWARD_FILE, json.dumps({"reward": verdict["reward"]}) + "\n")
+    return verdict
+
+
+def _write_new(directory, name, text):
+    """Write ``directory/name`` through a new file and a rename, so the name ends up a regular file whatever was
+    there."""
+
+    temporary = os.path.join(directory, ".%s.%d.tmp" % (name, os.getpid()))
+    fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    try:
+        _write_all(fd, text.encode("utf-8"))
+        os.fsync(fd)
+    finally:
+        os.close(fd)
+    os.replace(temporary, os.path.join(directory, name))
+
+
+def verify_main(argv):
+    parser = argparse.ArgumentParser(prog="textcraft_game.py verify", description="Grade a TextCraft action log.")
+    parser.add_argument("--task", required=True, help="the trusted task.json")
+    parser.add_argument("--recipes", required=True, help="the trusted recipes.json")
+    parser.add_argument("--root", required=True, help="the sandbox root the log path is below")
+    parser.add_argument("--log", required=True, help="the log's path below the root")
+    parser.add_argument("--out", required=True, help="the verifier's output directory (reward.json)")
+    options = parser.parse_args(argv)
+    try:
+        verdict = verify(options.task, options.recipes, options.root, options.log, options.out)
+    except (OSError, ValueError, KeyError) as exc:
+        print("textcraft verify: cannot grade: %s" % exc, file=sys.stderr)
+        return 1
+    print(
+        "reward %g: %s (%d records, %d crafts)"
+        % (verdict["reward"], verdict["reason"], verdict["records"], verdict["crafts"])
+    )
+    return 0
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv[:1] == ["verify"]:
+        return verify_main(argv[1:])
+    result = run(argv)
+    if result.out:
+        print(result.out)
+    if result.err:
+        print(result.err, file=sys.stderr)
+    return result.code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/textcraft-synth-train-easy-00604/instruction.md

@@ -0,0 +1,38 @@
+You are an agent in a crafting game. Your goal is to craft items by combining ingredients.
+You have access to an inventory of existing ingredients, which are sufficient to craft the target items; though, you may need to craft intermediate ingredients first.
+
+Note: If you already have one of the target items in your inventory, you should craft the requested number of the target on top of what you already have.
+For example, if you already have 2 wooden_pickaxes but your goal is to craft 3, your inventory should end up with 5 wooden_pickaxes.
+
+## Task
+
+Craft the following items: 1x t8_i3
+
+## Actions
+
+You act through the `textcraft` command in the shell:
+
+1. `textcraft craft TARGET TOTAL_COUNT INGREDIENT=COUNT [INGREDIENT=COUNT ...]`
+   Craft items using ingredients from your inventory.
+   - INGREDIENT=COUNT pairs: the items to consume and how many of each
+   - TARGET TOTAL_COUNT: the item to craft and its total count, which must be divisible by the recipe's result_count
+   - Example: `textcraft craft m2_i2 2 m0_i1=2 m1_i1=1`
+
+2. `textcraft info ITEM [ITEM ...]`
+   Get recipe information for items.
+   - Prints a JSON list with {"item": str, "can_craft": bool, "is_base": bool, "in_inventory": int, "crafting_depth": int, "recipes": [...]}
+   - crafting_depth indicates complexity: 0=base item, 1=direct craft, 2+=needs intermediate steps
+   - Each recipe shows {"ingredients": {...}, "result_count": int}
+   - Example: `textcraft info m2_i2 raw_m0`
+
+3. `textcraft inventory`
+   View your current inventory.
+   - Prints JSON {item_name: count}
+
+4. `textcraft finish MESSAGE`
+   Complete the task.
+   - Example: `textcraft finish "Successfully crafted all required items"`
+   - The task is graded when you finish, on what your inventory gained; no command is accepted after it, and a
+     task that never finishes counts as failed.
+
+The game keeps its state in `/app/textcraft`; change it only through the `textcraft` command.

tasks/textcraft-synth-train-easy-00604/solution/solve.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+# The reference solution of textcraft-synth-train-easy-00604: the source task's gold trajectory (3 crafts), then finish.
+set -euo pipefail
+if ! command -v textcraft >/dev/null 2>&1; then
+  # platoon's process provider runs no image, so there is no textcraft command: run the game file itself.
+  textcraft() { python3 -I "${PLATOON_SANDBOX_ROOT:-}/app/textcraft/textcraft_game.py" "$@"; }
+fi
+textcraft craft t6_i1_16 3 raw_t0=1
+textcraft craft t4_i2 2 raw_t8=1 raw_t9=1
+textcraft craft t8_i3 1 t4_i2=1 t6_i1_16=2
+textcraft finish 'Crafted 1x t8_i3'

tasks/textcraft-synth-train-easy-00604/task.toml

@@ -0,0 +1,33 @@
+schema_version = "1.4"
+# The game's action log: a separate verifier receives it at the same path.
+artifacts = ["/app/textcraft/actions.jsonl"]
+
+[task]
+name = "textcraft-synth/train-easy-00604"
+description = "TextCraft-Synth: craft the following items: 1x t8_i3 (easy, crafting depth 3)"
+keywords = ["textcraft", "textcraft-synth", "crafting", "planning"]
+
+[metadata]
+environment = "textcraft-synth@1"
+split = "train"
+difficulty = "easy"
+max_depth = 3
+num_craft_steps = 3
+goal = "Craft the following items: 1x t8_i3"
+source_task_id = "textcraft_synth.train.604"
+env_task_id = "train:604"
+env_split_task_id = "train-easy:129"
+
+[verifier]
+environment_mode = "separate"
+timeout_sec = 180.0
+
+[agent]
+timeout_sec = 660.0
+
+[environment]
+network_mode = "no-network"
+cpus = 1
+memory_mb = 2048
+gpus = 0
+build_timeout_sec = 900.0

tasks/textcraft-synth-train-easy-00604/tests/Dockerfile

@@ -0,0 +1,13 @@
+# textcraft-synth-train-easy-00604: task.json sha256:4106a4385ee832fa7bf9462de7c0e9623ed32581e908cf603ed669be276d99be
+FROM docker.io/library/python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1
+# The same image as the task's environment, so one image serves the agent and the verifier.
+RUN set -eux; \
+    printf '#!/bin/sh\nexec python3 -I /app/textcraft/textcraft_game.py "$@"\n' \
+        > /usr/local/bin/textcraft; \
+    chmod 0755 /usr/local/bin/textcraft; \
+    apt-get -o APT::Sandbox::User=root update; \
+    apt-get -o APT::Sandbox::User=root install -y --no-install-recommends tmux; \
+    rm -rf /var/lib/apt/lists/*
+# The verifier's trusted copies of the grader, the game, the recipes and the task.
+WORKDIR /app
+COPY test.sh textcraft_game.py recipes.json task.json /tests/

tasks/textcraft-synth-train-easy-00604/tests/task.json

@@ -0,0 +1,18 @@
+{
+ "format": "textcraft-task/1",
+ "name": "textcraft-synth-train-easy-00604",
+ "world": "textcraft-synth",
+ "goal": "Craft the following items: 1x t8_i3",
+ "target_items": {
+  "t8_i3": 1
+ },
+ "initial_inventory": {
+  "raw_t8": 2,
+  "raw_t9": 1,
+  "raw_t0": 2,
+  "raw_o8": 3,
+  "raw_o4": 1,
+  "m9_ore": 4
+ },
+ "recipes_sha256": "a020eec273337c66b35c0fc487664e35c44da65ad18e9afffe6a4c25af949f10"
+}

tasks/textcraft-synth-train-easy-00604/tests/test.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# Grade a TextCraft episode: replay the agent's action log (/app/textcraft/actions.jsonl) from the task's starting
+# inventory with the game's rules, using this directory's own copies of the game, the recipes and the task.  The
+# reward is 1 only when the log is an episode the rules allow that ends in `textcraft finish` with every target
+# crafted (the verdict goes to textcraft-verdict.json).  It runs in the agent's container (a shared verifier) or in a
+# separate verifier that received the log as an artifact.
+# PLATOON_SANDBOX_ROOT: platoon's process provider runs this on the host, with the sandbox's files below that
+# directory; sandboxes leave it unset.
+set -u
+root="${PLATOON_SANDBOX_ROOT:-}"
+tests="$root/tests"
+out="$root/logs/verifier"
+mkdir -p "$out"
+# A fresh verdict: nothing the agent may have left in the verifier's directory counts.
+rm -rf -- "$out/reward.json" "$out/reward.txt" "$out/textcraft-verdict.json"
+exec python3 -I "$tests/textcraft_game.py" verify --task "$tests/task.json" --recipes "$tests/recipes.json" \
+  --root "$root/" --log app/textcraft/actions.jsonl --out "$out"

tasks/textcraft-synth-train-easy-00604/tests/textcraft_game.py

@@ -0,0 +1,756 @@
+"""TextCraft in a container: the ``textcraft`` command of a Harbor task, and the verifier that grades it.
+
+This one file is the whole game.  It needs Python 3.8 or later and its standard library only, and it never imports
+platoon: the exporter (``python -m platoon.textcraft.harbor export``) copies it into every task as
+``textcraft_game.py``, into ``environment/`` (the container gets it at ``/app/textcraft/textcraft_game.py``, which
+the image's ``textcraft`` command runs) and into ``tests/`` for the verifier.  It reproduces platoon's TextCraft
+environments (``platoon.textcraft.env``): the same four tools with the same arguments, the same observation text
+and the same success rule.
+
+=========================================  ===================  ===============================================
+command                                    environment tool     prints
+=========================================  ===================  ===============================================
+``textcraft craft TARGET COUNT ING=N ...``  ``craft``            ``Successfully crafted ...`` or ``Error: ...``
+``textcraft info ITEM ...``                 ``get_info``         the recipe information, as JSON
+``textcraft inventory``                     ``view_inventory``   the inventory, as JSON
+``textcraft finish MESSAGE``                ``finish``           the message; the episode ends
+=========================================  ===================  ===============================================
+
+``craft --json '{"ingredients": {...}, "target": [item, count]}'`` and ``info --json '[item, ...]'`` take a tool's
+arguments as JSON values, the way a tool call passes them.
+
+**State.**  ``$TEXTCRAFT_DIR`` (default: this file's directory, ``/app/textcraft`` in a task's container) holds the
+task (``task.json``: goal, targets, starting inventory), the world's recipes (``recipes.json``, or
+``$TEXTCRAFT_RECIPES``) and the action log (``actions.jsonl``).  The log is the state: under an exclusive lock,
+every command replays the log from the starting inventory, runs, and appends its own record (``{"seq", "tool",
+"args"}``, plus ``"ok"`` for a craft).  Nothing is accepted after ``finish``, or once the log no longer replays.
+
+**Grading** (``python3 textcraft_game.py verify``, from the task's ``tests/test.sh``) replays the log with trusted
+copies of the task and the recipes.  The reward is 1 when the log is an episode the rules allow that ends in
+``finish`` with a message, and the inventory then holds every target count on top of the starting inventory (the
+environment's rule); otherwise it is 0.  The log must be a regular file of at most 32 MiB, reached without a
+symbolic link below the sandbox root.  A record that does not parse, breaks the record format or the numbering,
+follows ``finish``, or claims a craft outcome the rules do not give ends the replay with reward 0: only a log the
+command could have written earns a reward.  A craft the rules reject, recorded as rejected, changes nothing, as in
+the environment.
+"""
+
+from __future__ import annotations
+
+import argparse
+import errno
+import fcntl
+import hashlib
+import json
+import os
+import stat
+import sys
+
+VERSION = "1.0"
+TASK_FORMAT = "textcraft-task/1"
+RECIPES_FORMAT = "textcraft-recipes/1"
+TASK_FILE = "task.json"
+LOG_FILE = "actions.jsonl"
+RECIPES_FILE = "recipes.json"
+REWARD_FILE = "reward.json"
+VERDICT_FILE = "textcraft-verdict.json"
+LOG_CAP_BYTES = 32 * 1024 * 1024
+CRAFTED = "Successfully crafted"
+# The environment's tools and their arguments, as a log record names them.
+ARGUMENTS = {"craft": ("ingredients", "target"), "get_info": ("items",), "view_inventory": (), "finish": ("message",)}
+READ_ONLY = frozenset({"get_info", "view_inventory"})  # tools that change nothing
+COMMANDS = {
+    "craft": "craft",
+    "info": "get_info",
+    "get_info": "get_info",
+    "inventory": "view_inventory",
+    "view_inventory": "view_inventory",
+    "finish": "finish",
+}
+_CLOEXEC = getattr(os, "O_CLOEXEC", 0)
+
+USAGE = """\
+usage: textcraft COMMAND [ARGUMENTS]
+
+Play the TextCraft task in $TEXTCRAFT_DIR (default /app/textcraft, the game's directory).
+
+  textcraft craft TARGET COUNT INGREDIENT=N [INGREDIENT=N ...]
+      Craft COUNT of TARGET from exactly these ingredients.  COUNT must be divisible by the recipe's
+      result_count; each ingredient's N is its recipe count times COUNT / result_count.
+      Example: textcraft craft m2_i2 2 m0_i1=2 m1_i1=1
+  textcraft info ITEM [ITEM ...]
+      Recipe information for the items, as a JSON list.
+  textcraft inventory
+      Your current inventory, as JSON {item_name: count}.
+  textcraft finish MESSAGE
+      Complete the task with a message saying what you achieved.  The task is graded on what your
+      inventory gained; no command is accepted after it.
+
+craft --json '{"ingredients": {...}, "target": [item, count]}' and info --json '[item, ...]' take the
+arguments as JSON.  get_info and view_inventory are other names for info and inventory.
+"""
+
+
+# ---------------------------------------------------------------------------------------------------- the world
+
+
+class Recipe:
+    __slots__ = ("result_count", "ingredients")
+
+    def __init__(self, result_count, ingredients):
+        self.result_count = result_count
+        self.ingredients = ingredients  # {item or "tag:<name>": count}, in the recipe's order
+
+
+class RecipeBook:
+    """A world's recipes (``recipes.json``), with the lookups of platoon's recipe databases.
+
+    The file lists each craftable item's recipes (ingredients as ``[name, count]`` pairs, in order), the base items,
+    every item's crafting depth (0 for items it does not list) and the items each ``tag:<name>`` ingredient accepts.
+    """
+
+    def __init__(self, data, sha256=None):
+        if not isinstance(data, dict) or data.get("format") != RECIPES_FORMAT:
+            raise ValueError("not a %s file" % RECIPES_FORMAT)
+        self.name = data["name"]
+        self.sha256 = sha256
+        self.recipes = {
+            item: [
+                Recipe(recipe["result_count"], {name: count for name, count in recipe["ingredients"]})
+                for recipe in recipes
+            ]
+            for item, recipes in data["recipes"].items()
+        }
+        self.base_items = frozenset(data["base_items"])
+        self.depths = dict(data["depths"])
+        self.tags = {tag: list(items) for tag, items in data["tags"].items()}
+
+    @classmethod
+    def load(cls, path):
+        with open(path, "rb") as handle:
+            raw = handle.read()
+        return cls(json.loads(raw.decode("utf-8")), sha256=hashlib.sha256(raw).hexdigest())
+
+    def get_recipes_for_item(self, item):
+        return self.recipes.get(item, [])
+
+    def can_craft(self, item):
+        return item in self.recipes
+
+    def is_base_item(self, item):
+        return item in self.base_items
+
+    def get_crafting_depth(self, item):
+        return self.depths.get(item, 0)
+
+    def get_items_for_tag(self, tag):
+        return list(self.tags.get(tag, []))
+
+
+def load_task(path):
+    """A task file (``task.json``): its goal, targets and starting inventory, and its recipes' SHA-256."""
+
+    with open(path, "rb") as handle:
+        task = json.loads(handle.read().decode("utf-8"))
+    if not isinstance(task, dict) or task.get("format") != TASK_FORMAT:
+        raise ValueError("%s is not a %s file" % (path, TASK_FORMAT))
+    for key in ("name", "goal", "target_items", "initial_inventory", "recipes_sha256"):
+        if key not in task:
+            raise ValueError("%s has no %r" % (path, key))
+    return task
+
+
+# ---------------------------------------------------------------------------------------------------- the game
+
+
+class Game:
+    """One episode: platoon's ``TextCraftEnvironment`` tools over an inventory, its rules and messages unchanged."""
+
+    def __init__(self, book, task):
+        self.book = book
+        self.goal = task["goal"]
+        self.target_items = dict(task["target_items"])
+        self.inventory = dict(task["initial_inventory"])
+        self.initial_inventory = dict(self.inventory)
+        self.finished = False
+        self.score = 0.0
+        self.reward_misc = {}
+        self.crafts = 0  # successful crafts
+
+    def call(self, tool, args):
+        """Run a tool with its arguments (the JSON values a tool call carries); the observation text it returns."""
+
+        if tool == "craft":
+            text = self.craft(args["ingredients"], args["target"])
+            self.crafts += text.startswith(CRAFTED)
+            return text
+        if tool == "get_info":
+            return json.dumps(self.get_info(args["items"]))
+        if tool == "view_inventory":
+            return json.dumps(dict(self.inventory))
+        if tool == "finish":
+            self.score, self.reward_misc = self.evaluate(args["message"])
+            self.finished = True
+            return args["message"]
+        raise ValueError("unknown tool %r" % (tool,))
+
+    def craft(self, ingredients, target):
+        """``TextCraftEnvironment._craft``: the same checks in the same order, with the same messages."""
+
+        if not isinstance(ingredients, dict):
+            return f"Error: ingredients must be a dict, got {type(ingredients).__name__}"
+        if not isinstance(target, (tuple, list)) or len(target) != 2:
+            return "Error: target must be a tuple of (item_name, count)"
+        target_item, target_count = target
+        if not isinstance(target_item, str):
+            return f"Error: target item must be a string, got {type(target_item).__name__}"
+        if not isinstance(target_count, int):
+            return f"Error: target count must be an int, got {type(target_count).__name__}"
+        if target_count <= 0:
+            return f"Error: target count must be positive, got {target_count}"
+        for ing_item, ing_count in ingredients.items():
+            if not isinstance(ing_item, str):
+                return f"Error: ingredient name must be a string, got {type(ing_item).__name__}"
+            if not isinstance(ing_count, int):
+                return f"Error: ingredient count for {ing_item} must be an int, got {type(ing_count).__name__}"
+            if ing_count <= 0:
+                return f"Error: ingredient count for {ing_item} must be positive, got {ing_count}"
+
+        book = self.book
+        recipes = book.get_recipes_for_item(target_item)
+        if not recipes:
+            return f"Error: No recipe found for {target_item}"
+
+        errors = []
+        for recipe_idx, recipe in enumerate(recipes):
+            if target_count % recipe.result_count != 0:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Target count {target_count} is not divisible "
+                    f"by recipe result count {recipe.result_count}"
+                )
+                continue
+            num_crafts = target_count // recipe.result_count
+
+            ingredient_mapping = {}  # recipe ingredient (or tag) -> provided item
+            recipe_error = None
+            for recipe_ing, recipe_count in recipe.ingredients.items():
+                total_required = recipe_count * num_crafts
+                if recipe_ing.startswith("tag:"):
+                    satisfying_items = book.get_items_for_tag(recipe_ing.replace("tag:", ""))
+                    provided = next(
+                        (
+                            item
+                            for item, count in ingredients.items()
+                            if item in satisfying_items and count == total_required
+                        ),
+                        None,
+                    )
+                    if provided is None:
+                        recipe_error = f"No ingredient provided for {recipe_ing}. Expected one of: {satisfying_items}"
+                        break
+                    ingredient_mapping[recipe_ing] = provided
+                else:
+                    if recipe_ing not in ingredients:
+                        recipe_error = f"Missing required ingredient {recipe_ing}"
+                        break
+                    if ingredients[recipe_ing] != total_required:
+                        recipe_error = (
+                            f"Wrong amount of {recipe_ing}. Need {total_required}, provided {ingredients[recipe_ing]}"
+                        )
+                        break
+                    ingredient_mapping[recipe_ing] = recipe_ing
+            if recipe_error:
+                errors.append(f"Recipe {recipe_idx + 1}: {recipe_error}")
+                continue
+
+            extra_ingredients = [item for item in ingredients if item not in ingredient_mapping.values()]
+            if extra_ingredients:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Extra ingredients not required: {', '.join(extra_ingredients)}"
+                )
+                continue
+
+            missing = []
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                required = recipe.ingredients[recipe_ing] * num_crafts
+                available = self.inventory.get(provided_ing, 0)
+                if available < required:
+                    missing.append(f"{provided_ing}: need {required}, have {available}")
+            if missing:
+                errors.append(f"Recipe {recipe_idx + 1}: Insufficient ingredients in inventory: {', '.join(missing)}")
+                continue
+
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                self.inventory[provided_ing] -= recipe.ingredients[recipe_ing] * num_crafts
+                if self.inventory[provided_ing] <= 0:
+                    del self.inventory[provided_ing]
+            crafted_count = recipe.result_count * num_crafts
+            self.inventory[target_item] = self.inventory.get(target_item, 0) + crafted_count
+            return f"Successfully crafted {crafted_count} {target_item}(s)"
+
+        return f"Error: All {len(recipes)} recipe(s) failed for {target_item}. Errors:\n" + "\n".join(errors)
+
+    def get_info(self, items):
+        """``TextCraftEnvironment._get_info``."""
+
+        book = self.book
+        results = []
+        for item in items:
+            info = {
+                "item": item,
+                "can_craft": book.can_craft(item),
+                "is_base": book.is_base_item(item),
+                "in_inventory": self.inventory.get(item, 0),
+                "crafting_depth": book.get_crafting_depth(item),
+                "recipes": [],
+            }
+            if info["can_craft"]:
+                for recipe in book.get_recipes_for_item(item):
+                    expanded = {}
+                    for ing, count in recipe.ingredients.items():
+                        if ing.startswith("tag:"):
+                            expanded[ing] = {"count": count, "use_one_of": book.get_items_for_tag(ing[4:])}
+                        else:
+                            expanded[ing] = count
+                    info["recipes"].append({"ingredients": expanded, "result_count": recipe.result_count})
+            results.append(info)
+        return results
+
+    def evaluate(self, finish_message):
+        """``TextCraftEnvironment.evaluate``: success when the inventory gained every target count and the finish
+        message is not empty."""
+
+        reward_misc = {}
+        score = 0.0
+        if finish_message:
+            if not self.target_items:
+                return 0.0, {"success": False, "error": "No target items defined in task", "reward/success": 0.0}
+            missing = {
+                item: required - (self.inventory.get(item, 0) - self.initial_inventory.get(item, 0))
+                for item, required in self.target_items.items()
+                if self.inventory.get(item, 0) - self.initial_inventory.get(item, 0) < required
+            }
+            reward_misc["success"] = not missing
+            if missing:
+                reward_misc["missing_items"] = missing
+            else:
+                score = 1.0
+            reward_misc["target_items"] = dict(self.target_items)
+            reward_misc["initial_inventory"] = dict(self.initial_inventory)
+            reward_misc["final_inventory"] = dict(self.inventory)
+        else:
+            reward_misc["success"] = False
+            reward_misc["error"] = "Episode ended without calling finish() - likely timeout or max steps reached"
+        reward_misc["reward/success"] = score
+        return score, reward_misc
+
+
+# ---------------------------------------------------------------------------------------------------- the log
+
+
+class LogError(ValueError):
+    """An action log the game could not have written: its replay stops there."""
+
+
+def _unique_pairs(pairs):
+    found = {}
+    for key, value in pairs:
+        if key in found:
+            raise ValueError("duplicate key %r" % (key,))
+        found[key] = value
+    return found
+
+
+def _no_constant(name):
+    raise ValueError("%s is not a JSON number" % name)
+
+
+def _finite_float(text):
+    value = float(text)
+    if value != value or value in (float("inf"), float("-inf")):
+        raise ValueError("%s is out of range" % text)
+    return value
+
+
+def parse_json(text):
+    """Strict JSON: no duplicate keys, no NaN or Infinity (also none that overflows, such as 1e999), so every value
+    it returns can be written back to the log."""
+
+    return json.loads(text, object_pairs_hook=_unique_pairs, parse_constant=_no_constant, parse_float=_finite_float)
+
+
+def encode_record(seq, tool, args, ok=None):
+    """A log line: ``{"seq", "tool", "args"}``, plus ``"ok"`` (the craft succeeded) for a craft."""
+
+    record = {"seq": seq, "tool": tool, "args": args}
+    if tool == "craft":
+        record["ok"] = bool(ok)
+    return (json.dumps(record, ensure_ascii=True, separators=(",", ":"), allow_nan=False) + "\n").encode("ascii")
+
+
+def check_arguments(tool, args):
+    """``args`` as a log record or a command may give them to ``tool``; ValueError says what is wrong."""
+
+    if not isinstance(args, dict) or sorted(args) != sorted(ARGUMENTS[tool]):
+        raise ValueError("%s takes the arguments %s" % (tool, ", ".join(ARGUMENTS[tool]) or "none"))
+    if tool == "get_info" and (
+        not isinstance(args["items"], list) or not all(isinstance(item, str) for item in args["items"])
+    ):
+        raise ValueError("get_info takes a list of item names")
+    if tool == "finish" and not isinstance(args["message"], str):
+        raise ValueError("finish takes a message string")
+
+
+def _record(line, seq):
+    try:
+        record = parse_json(line.decode("utf-8"))
+    except (UnicodeDecodeError, ValueError, RecursionError) as exc:
+        raise LogError("record %d is not a JSON object: %s" % (seq, exc)) from None
+    if not isinstance(record, dict):
+        raise LogError("record %d is not a JSON object" % seq)
+    tool = record.get("tool")
+    if not isinstance(tool, str) or tool not in ARGUMENTS:
+        raise LogError("record %d names no tool of the game: %r" % (seq, tool))
+    keys = {"seq", "tool", "args", "ok"} if tool == "craft" else {"seq", "tool", "args"}
+    if set(record) != keys:
+        raise LogError("record %d must have exactly the keys %s" % (seq, sorted(keys)))
+    if type(record["seq"]) is not int or record["seq"] != seq:
+        raise LogError("record %d is numbered %r" % (seq, record["seq"]))
+    try:
+        check_arguments(tool, record["args"])
+    except ValueError as exc:
+        raise LogError("record %d: %s" % (seq, exc)) from None
+    if tool == "craft" and not isinstance(record["ok"], bool):
+        raise LogError("record %d: ok must be true or false" % seq)
+    return tool, record["args"], record.get("ok")
+
+
+def replay(game, data):
+    """Apply a log's records to ``game``; how many there were.  LogError at the first record the game could not
+    have written: the replay stops there.
+
+    The records are read one at a time, and those of ``get_info`` and ``view_inventory``, which change nothing, have
+    their arguments checked but their output never rebuilt, so replaying any log within the size cap takes seconds
+    and a bounded amount of memory (a ``get_info`` record can name millions of items)."""
+
+    if not data:
+        return 0
+    if not data.endswith(b"\n"):
+        raise LogError("the last record does not end with a newline")
+    seq = start = 0
+    while start < len(data):
+        end = data.index(b"\n", start)
+        seq += 1
+        if game.finished:
+            raise LogError("record %d follows finish" % seq)
+        tool, args, ok = _record(data[start:end], seq)
+        start = end + 1
+        if tool in READ_ONLY:
+            continue
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:  # arguments no command writes
+            raise LogError("record %d cannot be applied: %s: %s" % (seq, type(exc).__name__, exc)) from None
+        if tool == "craft" and text.startswith(CRAFTED) != ok:
+            claim = "succeeded" if ok else "failed"
+            raise LogError("record %d says the craft %s, but the rules give: %s" % (seq, claim, text))
+    return seq
+
+
+# ---------------------------------------------------------------------------------------------------- the command
+
+
+class UsageError(ValueError):
+    pass
+
+
+class Result:
+    """What a command printed and its exit status: 0 done, 1 a game error (a rejected craft, the episode is over),
+    2 a usage error (nothing was run or logged), 3 the task cannot be played."""
+
+    def __init__(self, code, out="", err=""):
+        self.code = code
+        self.out = out
+        self.err = err
+
+
+def parse_command(argv):
+    """``(tool, args)`` of a command line; UsageError when it is not one."""
+
+    if not argv:
+        raise UsageError("no command")
+    tool = COMMANDS.get(argv[0])
+    if tool is None:
+        raise UsageError("unknown command %r" % argv[0])
+    rest = argv[1:]
+    if tool == "craft":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("craft --json takes one JSON object")
+            args = _json_argument(rest[1])
+            if not isinstance(args, dict) or sorted(args) != ["ingredients", "target"]:
+                raise UsageError('craft --json takes {"ingredients": {...}, "target": [item, count]}')
+            return tool, args
+        if len(rest) < 2:
+            raise UsageError("craft takes TARGET COUNT INGREDIENT=N ...")
+        ingredients = {}
+        for word in rest[2:]:
+            name, sep, count = word.rpartition("=")
+            if not sep or not name:
+                raise UsageError("ingredients are INGREDIENT=N, got %r" % word)
+            if name in ingredients:
+                raise UsageError("ingredient %r is given twice" % name)
+            ingredients[name] = _integer(count, "the count of %s" % name)
+        return tool, {"ingredients": ingredients, "target": [rest[0], _integer(rest[1], "COUNT")]}
+    if tool == "get_info":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("info --json takes one JSON list")
+            items = _json_argument(rest[1])
+        else:
+            items = list(rest)
+        args = {"items": items}
+    elif tool == "view_inventory":
+        if rest:
+            raise UsageError("inventory takes no arguments")
+        args = {}
+    else:
+        if not rest:
+            raise UsageError("finish takes a MESSAGE saying what you achieved")
+        args = {"message": " ".join(rest)}
+    try:
+        check_arguments(tool, args)
+    except ValueError as exc:
+        raise UsageError(str(exc)) from None
+    return tool, args
+
+
+def _json_argument(text):
+    try:
+        return parse_json(text)
+    except (ValueError, RecursionError) as exc:
+        raise UsageError("not valid JSON: %s" % exc) from None
+
+
+def _integer(text, what):
+    try:
+        return int(text)
+    except ValueError:
+        raise UsageError("%s must be an integer, got %r" % (what, text)) from None
+
+
+def default_directory():
+    return os.environ.get("TEXTCRAFT_DIR") or os.path.dirname(os.path.abspath(__file__))
+
+
+def run(argv, directory=None, recipes=None):
+    """Run a command line against the task in ``directory`` (default ``$TEXTCRAFT_DIR``, else this file's
+    directory), with the recipes ``recipes`` (default ``$TEXTCRAFT_RECIPES``, else the directory's
+    ``recipes.json``)."""
+
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        return Result(0 if argv else 2, USAGE)
+    if argv[0] == "--version":
+        return Result(0, "textcraft %s" % VERSION)
+    try:
+        tool, args = parse_command(argv)
+    except UsageError as exc:
+        return Result(2, err="textcraft: %s\n\n%s" % (exc, USAGE))
+    directory = directory or default_directory()
+    try:
+        task = load_task(os.path.join(directory, TASK_FILE))
+        book = RecipeBook.load(recipes or os.environ.get("TEXTCRAFT_RECIPES") or os.path.join(directory, RECIPES_FILE))
+    except (OSError, ValueError, KeyError) as exc:
+        return Result(3, err="textcraft: cannot load the task: %s" % exc)
+    if task["recipes_sha256"] != book.sha256:
+        return Result(3, err="textcraft: the recipes (%s) are not the ones of this task" % book.sha256)
+    path = os.path.join(directory, LOG_FILE)
+    try:
+        fd = os.open(path, os.O_RDWR | os.O_CREAT | os.O_APPEND | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    except OSError as exc:
+        why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+        return Result(3, err="textcraft: cannot open the action log %s: %s" % (path, why))
+    try:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_EX)
+        except OSError:
+            pass  # a file system without locks: commands are not expected to overlap
+        if not stat.S_ISREG(os.fstat(fd).st_mode):
+            return Result(3, err="textcraft: the action log %s is not a regular file" % path)
+        data = _read_all(fd)
+        game = Game(book, task)
+        try:
+            seq = replay(game, data) + 1
+        except LogError as exc:
+            return Result(
+                3, err="textcraft: the action log %s does not replay (%s); the episode cannot continue" % (path, exc)
+            )
+        if game.finished:
+            return Result(
+                1, "Error: the episode is finished (textcraft finish was called); no command is accepted after it"
+            )
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:
+            return Result(2, err="textcraft: cannot run %s: %s: %s" % (tool, type(exc).__name__, exc))
+        ok = text.startswith(CRAFTED)
+        line = encode_record(seq, tool, args, ok)
+        if len(data) + len(line) > LOG_CAP_BYTES:
+            return Result(1, "Error: the action log is full (%d bytes); no command is accepted" % LOG_CAP_BYTES)
+        _write_all(fd, line)
+    finally:
+        os.close(fd)
+    return Result(1 if tool == "craft" and not ok else 0, text)
+
+
+def _read_all(fd):
+    os.lseek(fd, 0, os.SEEK_SET)
+    chunks = []
+    while True:
+        chunk = os.read(fd, 1 << 20)
+        if not chunk:
+            return b"".join(chunks)
+        chunks.append(chunk)
+
+
+def _write_all(fd, data):
+    view = memoryview(data)
+    while view:
+        view = view[os.write(fd, view) :]
+
+
+# ---------------------------------------------------------------------------------------------------- the verifier
+
+
+def read_untrusted(root, relative, cap=LOG_CAP_BYTES):
+    """The bytes of ``root/relative``, reached without following a symbolic link below ``root``; None when it does
+    not exist.  LogError when it is not a regular file, or holds more than ``cap`` bytes."""
+
+    parts = [part for part in relative.split("/") if part not in ("", ".")]
+    if not parts or ".." in parts:
+        raise ValueError("%r is not a path below the root" % relative)
+    directory = os.open(root, os.O_RDONLY | os.O_DIRECTORY | _CLOEXEC)
+    try:
+        for part in parts[:-1]:
+            try:
+                below = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW | _CLOEXEC, dir_fd=directory)
+            except FileNotFoundError:
+                return None
+            except OSError as exc:
+                raise LogError("%s on the way to the action log is not a directory (%s)" % (part, exc.strerror))
+            os.close(directory)
+            directory = below
+        try:
+            fd = os.open(parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK | _CLOEXEC, dir_fd=directory)
+        except FileNotFoundError:
+            return None
+        except OSError as exc:
+            why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+            raise LogError("cannot open the action log: %s" % why)
+    finally:
+        os.close(directory)
+    try:
+        info = os.fstat(fd)
+        if not stat.S_ISREG(info.st_mode):
+            raise LogError("the action log is not a regular file")
+        if info.st_size > cap:
+            raise LogError("the action log holds %d bytes; the limit is %d" % (info.st_size, cap))
+        chunks, total = [], 0
+        while total <= cap:
+            chunk = os.read(fd, min(1 << 20, cap + 1 - total))
+            if not chunk:
+                break
+            chunks.append(chunk)
+            total += len(chunk)
+        if total > cap:
+            raise LogError("the action log holds more than %d bytes" % cap)
+        return b"".join(chunks)
+    finally:
+        os.close(fd)
+
+
+def verify(task_path, recipes_path, root, log, out=None):
+    """Grade the log at ``root/log`` against the trusted task and recipes; the verdict (``reward`` and why).
+    Writes ``reward.json`` and ``textcraft-verdict.json`` into ``out`` when given."""
+
+    task = load_task(task_path)
+    book = RecipeBook.load(recipes_path)
+    if task["recipes_sha256"] != book.sha256:
+        raise ValueError("the verifier's recipes %s are not the task's %s" % (book.sha256, task["recipes_sha256"]))
+    game = Game(book, task)
+    verdict = {"reward": 0.0, "task": task["name"], "version": VERSION, "records": 0, "crafts": 0, "finished": False}
+    try:
+        data = read_untrusted(root, log)
+        if data is None:
+            verdict["reason"] = "no action log: no textcraft command ran"
+        else:
+            verdict["log_bytes"] = len(data)
+            verdict["records"] = replay(game, data)
+            verdict["crafts"] = game.crafts
+            verdict["finished"] = game.finished
+            if not game.finished:
+                verdict["reason"] = "the episode did not end with textcraft finish"
+            elif game.score >= 1.0:
+                verdict["reward"] = 1.0
+                verdict["reason"] = "finished with every target crafted"
+            elif game.reward_misc.get("missing_items"):
+                verdict["reason"] = "finished without every target crafted"
+                verdict["missing_items"] = game.reward_misc["missing_items"]
+            else:
+                verdict["reason"] = "finished with an empty message"
+    except LogError as exc:
+        verdict["reason"] = "the action log is not one the game wrote: %s" % exc
+    if out is not None:
+        _write_new(out, VERDICT_FILE, json.dumps(verdict, indent=1, sort_keys=True) + "\n")
+        _write_new(out, REWARD_FILE, json.dumps({"reward": verdict["reward"]}) + "\n")
+    return verdict
+
+
+def _write_new(directory, name, text):
+    """Write ``directory/name`` through a new file and a rename, so the name ends up a regular file whatever was
+    there."""
+
+    temporary = os.path.join(directory, ".%s.%d.tmp" % (name, os.getpid()))
+    fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    try:
+        _write_all(fd, text.encode("utf-8"))
+        os.fsync(fd)
+    finally:
+        os.close(fd)
+    os.replace(temporary, os.path.join(directory, name))
+
+
+def verify_main(argv):
+    parser = argparse.ArgumentParser(prog="textcraft_game.py verify", description="Grade a TextCraft action log.")
+    parser.add_argument("--task", required=True, help="the trusted task.json")
+    parser.add_argument("--recipes", required=True, help="the trusted recipes.json")
+    parser.add_argument("--root", required=True, help="the sandbox root the log path is below")
+    parser.add_argument("--log", required=True, help="the log's path below the root")
+    parser.add_argument("--out", required=True, help="the verifier's output directory (reward.json)")
+    options = parser.parse_args(argv)
+    try:
+        verdict = verify(options.task, options.recipes, options.root, options.log, options.out)
+    except (OSError, ValueError, KeyError) as exc:
+        print("textcraft verify: cannot grade: %s" % exc, file=sys.stderr)
+        return 1
+    print(
+        "reward %g: %s (%d records, %d crafts)"
+        % (verdict["reward"], verdict["reason"], verdict["records"], verdict["crafts"])
+    )
+    return 0
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv[:1] == ["verify"]:
+        return verify_main(argv[1:])
+    result = run(argv)
+    if result.out:
+        print(result.out)
+    if result.err:
+        print(result.err, file=sys.stderr)
+    return result.code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/textcraft-synth-train-easy-00615/environment/Dockerfile

@@ -0,0 +1,17 @@
+# textcraft-synth-train-easy-00615: task.json sha256:efe8d61ade9146914304ab7b7b6a97a36a3c65e5fa0d699c8c399c783b66e8da
+FROM docker.io/library/python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1
+# The image is the same for every task (and for the verifier): Python, tmux for terminal agents, and the
+# `textcraft` command, which runs the game file below.
+RUN set -eux; \
+    printf '#!/bin/sh\nexec python3 -I /app/textcraft/textcraft_game.py "$@"\n' \
+        > /usr/local/bin/textcraft; \
+    chmod 0755 /usr/local/bin/textcraft; \
+    apt-get -o APT::Sandbox::User=root update; \
+    apt-get -o APT::Sandbox::User=root install -y --no-install-recommends tmux; \
+    rm -rf /var/lib/apt/lists/*
+# The game and the world's recipes (the same in every task), then this task's goal and starting inventory.  The
+# game keeps its action log next to them.
+WORKDIR /app
+ENV TEXTCRAFT_DIR=/app/textcraft
+COPY textcraft_game.py recipes.json /app/textcraft/
+COPY task.json /app/textcraft/

tasks/textcraft-synth-train-easy-00615/environment/task.json

@@ -0,0 +1,16 @@
+{
+ "format": "textcraft-task/1",
+ "name": "textcraft-synth-train-easy-00615",
+ "world": "textcraft-synth",
+ "goal": "Craft the following items: 3x t0_i3",
+ "target_items": {
+  "t0_i3": 3
+ },
+ "initial_inventory": {
+  "raw_t3": 3,
+  "raw_t9": 16,
+  "raw_t1": 7,
+  "raw_a2": 2
+ },
+ "recipes_sha256": "a020eec273337c66b35c0fc487664e35c44da65ad18e9afffe6a4c25af949f10"
+}

tasks/textcraft-synth-train-easy-00615/environment/textcraft_game.py

@@ -0,0 +1,756 @@
+"""TextCraft in a container: the ``textcraft`` command of a Harbor task, and the verifier that grades it.
+
+This one file is the whole game.  It needs Python 3.8 or later and its standard library only, and it never imports
+platoon: the exporter (``python -m platoon.textcraft.harbor export``) copies it into every task as
+``textcraft_game.py``, into ``environment/`` (the container gets it at ``/app/textcraft/textcraft_game.py``, which
+the image's ``textcraft`` command runs) and into ``tests/`` for the verifier.  It reproduces platoon's TextCraft
+environments (``platoon.textcraft.env``): the same four tools with the same arguments, the same observation text
+and the same success rule.
+
+=========================================  ===================  ===============================================
+command                                    environment tool     prints
+=========================================  ===================  ===============================================
+``textcraft craft TARGET COUNT ING=N ...``  ``craft``            ``Successfully crafted ...`` or ``Error: ...``
+``textcraft info ITEM ...``                 ``get_info``         the recipe information, as JSON
+``textcraft inventory``                     ``view_inventory``   the inventory, as JSON
+``textcraft finish MESSAGE``                ``finish``           the message; the episode ends
+=========================================  ===================  ===============================================
+
+``craft --json '{"ingredients": {...}, "target": [item, count]}'`` and ``info --json '[item, ...]'`` take a tool's
+arguments as JSON values, the way a tool call passes them.
+
+**State.**  ``$TEXTCRAFT_DIR`` (default: this file's directory, ``/app/textcraft`` in a task's container) holds the
+task (``task.json``: goal, targets, starting inventory), the world's recipes (``recipes.json``, or
+``$TEXTCRAFT_RECIPES``) and the action log (``actions.jsonl``).  The log is the state: under an exclusive lock,
+every command replays the log from the starting inventory, runs, and appends its own record (``{"seq", "tool",
+"args"}``, plus ``"ok"`` for a craft).  Nothing is accepted after ``finish``, or once the log no longer replays.
+
+**Grading** (``python3 textcraft_game.py verify``, from the task's ``tests/test.sh``) replays the log with trusted
+copies of the task and the recipes.  The reward is 1 when the log is an episode the rules allow that ends in
+``finish`` with a message, and the inventory then holds every target count on top of the starting inventory (the
+environment's rule); otherwise it is 0.  The log must be a regular file of at most 32 MiB, reached without a
+symbolic link below the sandbox root.  A record that does not parse, breaks the record format or the numbering,
+follows ``finish``, or claims a craft outcome the rules do not give ends the replay with reward 0: only a log the
+command could have written earns a reward.  A craft the rules reject, recorded as rejected, changes nothing, as in
+the environment.
+"""
+
+from __future__ import annotations
+
+import argparse
+import errno
+import fcntl
+import hashlib
+import json
+import os
+import stat
+import sys
+
+VERSION = "1.0"
+TASK_FORMAT = "textcraft-task/1"
+RECIPES_FORMAT = "textcraft-recipes/1"
+TASK_FILE = "task.json"
+LOG_FILE = "actions.jsonl"
+RECIPES_FILE = "recipes.json"
+REWARD_FILE = "reward.json"
+VERDICT_FILE = "textcraft-verdict.json"
+LOG_CAP_BYTES = 32 * 1024 * 1024
+CRAFTED = "Successfully crafted"
+# The environment's tools and their arguments, as a log record names them.
+ARGUMENTS = {"craft": ("ingredients", "target"), "get_info": ("items",), "view_inventory": (), "finish": ("message",)}
+READ_ONLY = frozenset({"get_info", "view_inventory"})  # tools that change nothing
+COMMANDS = {
+    "craft": "craft",
+    "info": "get_info",
+    "get_info": "get_info",
+    "inventory": "view_inventory",
+    "view_inventory": "view_inventory",
+    "finish": "finish",
+}
+_CLOEXEC = getattr(os, "O_CLOEXEC", 0)
+
+USAGE = """\
+usage: textcraft COMMAND [ARGUMENTS]
+
+Play the TextCraft task in $TEXTCRAFT_DIR (default /app/textcraft, the game's directory).
+
+  textcraft craft TARGET COUNT INGREDIENT=N [INGREDIENT=N ...]
+      Craft COUNT of TARGET from exactly these ingredients.  COUNT must be divisible by the recipe's
+      result_count; each ingredient's N is its recipe count times COUNT / result_count.
+      Example: textcraft craft m2_i2 2 m0_i1=2 m1_i1=1
+  textcraft info ITEM [ITEM ...]
+      Recipe information for the items, as a JSON list.
+  textcraft inventory
+      Your current inventory, as JSON {item_name: count}.
+  textcraft finish MESSAGE
+      Complete the task with a message saying what you achieved.  The task is graded on what your
+      inventory gained; no command is accepted after it.
+
+craft --json '{"ingredients": {...}, "target": [item, count]}' and info --json '[item, ...]' take the
+arguments as JSON.  get_info and view_inventory are other names for info and inventory.
+"""
+
+
+# ---------------------------------------------------------------------------------------------------- the world
+
+
+class Recipe:
+    __slots__ = ("result_count", "ingredients")
+
+    def __init__(self, result_count, ingredients):
+        self.result_count = result_count
+        self.ingredients = ingredients  # {item or "tag:<name>": count}, in the recipe's order
+
+
+class RecipeBook:
+    """A world's recipes (``recipes.json``), with the lookups of platoon's recipe databases.
+
+    The file lists each craftable item's recipes (ingredients as ``[name, count]`` pairs, in order), the base items,
+    every item's crafting depth (0 for items it does not list) and the items each ``tag:<name>`` ingredient accepts.
+    """
+
+    def __init__(self, data, sha256=None):
+        if not isinstance(data, dict) or data.get("format") != RECIPES_FORMAT:
+            raise ValueError("not a %s file" % RECIPES_FORMAT)
+        self.name = data["name"]
+        self.sha256 = sha256
+        self.recipes = {
+            item: [
+                Recipe(recipe["result_count"], {name: count for name, count in recipe["ingredients"]})
+                for recipe in recipes
+            ]
+            for item, recipes in data["recipes"].items()
+        }
+        self.base_items = frozenset(data["base_items"])
+        self.depths = dict(data["depths"])
+        self.tags = {tag: list(items) for tag, items in data["tags"].items()}
+
+    @classmethod
+    def load(cls, path):
+        with open(path, "rb") as handle:
+            raw = handle.read()
+        return cls(json.loads(raw.decode("utf-8")), sha256=hashlib.sha256(raw).hexdigest())
+
+    def get_recipes_for_item(self, item):
+        return self.recipes.get(item, [])
+
+    def can_craft(self, item):
+        return item in self.recipes
+
+    def is_base_item(self, item):
+        return item in self.base_items
+
+    def get_crafting_depth(self, item):
+        return self.depths.get(item, 0)
+
+    def get_items_for_tag(self, tag):
+        return list(self.tags.get(tag, []))
+
+
+def load_task(path):
+    """A task file (``task.json``): its goal, targets and starting inventory, and its recipes' SHA-256."""
+
+    with open(path, "rb") as handle:
+        task = json.loads(handle.read().decode("utf-8"))
+    if not isinstance(task, dict) or task.get("format") != TASK_FORMAT:
+        raise ValueError("%s is not a %s file" % (path, TASK_FORMAT))
+    for key in ("name", "goal", "target_items", "initial_inventory", "recipes_sha256"):
+        if key not in task:
+            raise ValueError("%s has no %r" % (path, key))
+    return task
+
+
+# ---------------------------------------------------------------------------------------------------- the game
+
+
+class Game:
+    """One episode: platoon's ``TextCraftEnvironment`` tools over an inventory, its rules and messages unchanged."""
+
+    def __init__(self, book, task):
+        self.book = book
+        self.goal = task["goal"]
+        self.target_items = dict(task["target_items"])
+        self.inventory = dict(task["initial_inventory"])
+        self.initial_inventory = dict(self.inventory)
+        self.finished = False
+        self.score = 0.0
+        self.reward_misc = {}
+        self.crafts = 0  # successful crafts
+
+    def call(self, tool, args):
+        """Run a tool with its arguments (the JSON values a tool call carries); the observation text it returns."""
+
+        if tool == "craft":
+            text = self.craft(args["ingredients"], args["target"])
+            self.crafts += text.startswith(CRAFTED)
+            return text
+        if tool == "get_info":
+            return json.dumps(self.get_info(args["items"]))
+        if tool == "view_inventory":
+            return json.dumps(dict(self.inventory))
+        if tool == "finish":
+            self.score, self.reward_misc = self.evaluate(args["message"])
+            self.finished = True
+            return args["message"]
+        raise ValueError("unknown tool %r" % (tool,))
+
+    def craft(self, ingredients, target):
+        """``TextCraftEnvironment._craft``: the same checks in the same order, with the same messages."""
+
+        if not isinstance(ingredients, dict):
+            return f"Error: ingredients must be a dict, got {type(ingredients).__name__}"
+        if not isinstance(target, (tuple, list)) or len(target) != 2:
+            return "Error: target must be a tuple of (item_name, count)"
+        target_item, target_count = target
+        if not isinstance(target_item, str):
+            return f"Error: target item must be a string, got {type(target_item).__name__}"
+        if not isinstance(target_count, int):
+            return f"Error: target count must be an int, got {type(target_count).__name__}"
+        if target_count <= 0:
+            return f"Error: target count must be positive, got {target_count}"
+        for ing_item, ing_count in ingredients.items():
+            if not isinstance(ing_item, str):
+                return f"Error: ingredient name must be a string, got {type(ing_item).__name__}"
+            if not isinstance(ing_count, int):
+                return f"Error: ingredient count for {ing_item} must be an int, got {type(ing_count).__name__}"
+            if ing_count <= 0:
+                return f"Error: ingredient count for {ing_item} must be positive, got {ing_count}"
+
+        book = self.book
+        recipes = book.get_recipes_for_item(target_item)
+        if not recipes:
+            return f"Error: No recipe found for {target_item}"
+
+        errors = []
+        for recipe_idx, recipe in enumerate(recipes):
+            if target_count % recipe.result_count != 0:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Target count {target_count} is not divisible "
+                    f"by recipe result count {recipe.result_count}"
+                )
+                continue
+            num_crafts = target_count // recipe.result_count
+
+            ingredient_mapping = {}  # recipe ingredient (or tag) -> provided item
+            recipe_error = None
+            for recipe_ing, recipe_count in recipe.ingredients.items():
+                total_required = recipe_count * num_crafts
+                if recipe_ing.startswith("tag:"):
+                    satisfying_items = book.get_items_for_tag(recipe_ing.replace("tag:", ""))
+                    provided = next(
+                        (
+                            item
+                            for item, count in ingredients.items()
+                            if item in satisfying_items and count == total_required
+                        ),
+                        None,
+                    )
+                    if provided is None:
+                        recipe_error = f"No ingredient provided for {recipe_ing}. Expected one of: {satisfying_items}"
+                        break
+                    ingredient_mapping[recipe_ing] = provided
+                else:
+                    if recipe_ing not in ingredients:
+                        recipe_error = f"Missing required ingredient {recipe_ing}"
+                        break
+                    if ingredients[recipe_ing] != total_required:
+                        recipe_error = (
+                            f"Wrong amount of {recipe_ing}. Need {total_required}, provided {ingredients[recipe_ing]}"
+                        )
+                        break
+                    ingredient_mapping[recipe_ing] = recipe_ing
+            if recipe_error:
+                errors.append(f"Recipe {recipe_idx + 1}: {recipe_error}")
+                continue
+
+            extra_ingredients = [item for item in ingredients if item not in ingredient_mapping.values()]
+            if extra_ingredients:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Extra ingredients not required: {', '.join(extra_ingredients)}"
+                )
+                continue
+
+            missing = []
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                required = recipe.ingredients[recipe_ing] * num_crafts
+                available = self.inventory.get(provided_ing, 0)
+                if available < required:
+                    missing.append(f"{provided_ing}: need {required}, have {available}")
+            if missing:
+                errors.append(f"Recipe {recipe_idx + 1}: Insufficient ingredients in inventory: {', '.join(missing)}")
+                continue
+
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                self.inventory[provided_ing] -= recipe.ingredients[recipe_ing] * num_crafts
+                if self.inventory[provided_ing] <= 0:
+                    del self.inventory[provided_ing]
+            crafted_count = recipe.result_count * num_crafts
+            self.inventory[target_item] = self.inventory.get(target_item, 0) + crafted_count
+            return f"Successfully crafted {crafted_count} {target_item}(s)"
+
+        return f"Error: All {len(recipes)} recipe(s) failed for {target_item}. Errors:\n" + "\n".join(errors)
+
+    def get_info(self, items):
+        """``TextCraftEnvironment._get_info``."""
+
+        book = self.book
+        results = []
+        for item in items:
+            info = {
+                "item": item,
+                "can_craft": book.can_craft(item),
+                "is_base": book.is_base_item(item),
+                "in_inventory": self.inventory.get(item, 0),
+                "crafting_depth": book.get_crafting_depth(item),
+                "recipes": [],
+            }
+            if info["can_craft"]:
+                for recipe in book.get_recipes_for_item(item):
+                    expanded = {}
+                    for ing, count in recipe.ingredients.items():
+                        if ing.startswith("tag:"):
+                            expanded[ing] = {"count": count, "use_one_of": book.get_items_for_tag(ing[4:])}
+                        else:
+                            expanded[ing] = count
+                    info["recipes"].append({"ingredients": expanded, "result_count": recipe.result_count})
+            results.append(info)
+        return results
+
+    def evaluate(self, finish_message):
+        """``TextCraftEnvironment.evaluate``: success when the inventory gained every target count and the finish
+        message is not empty."""
+
+        reward_misc = {}
+        score = 0.0
+        if finish_message:
+            if not self.target_items:
+                return 0.0, {"success": False, "error": "No target items defined in task", "reward/success": 0.0}
+            missing = {
+                item: required - (self.inventory.get(item, 0) - self.initial_inventory.get(item, 0))
+                for item, required in self.target_items.items()
+                if self.inventory.get(item, 0) - self.initial_inventory.get(item, 0) < required
+            }
+            reward_misc["success"] = not missing
+            if missing:
+                reward_misc["missing_items"] = missing
+            else:
+                score = 1.0
+            reward_misc["target_items"] = dict(self.target_items)
+            reward_misc["initial_inventory"] = dict(self.initial_inventory)
+            reward_misc["final_inventory"] = dict(self.inventory)
+        else:
+            reward_misc["success"] = False
+            reward_misc["error"] = "Episode ended without calling finish() - likely timeout or max steps reached"
+        reward_misc["reward/success"] = score
+        return score, reward_misc
+
+
+# ---------------------------------------------------------------------------------------------------- the log
+
+
+class LogError(ValueError):
+    """An action log the game could not have written: its replay stops there."""
+
+
+def _unique_pairs(pairs):
+    found = {}
+    for key, value in pairs:
+        if key in found:
+            raise ValueError("duplicate key %r" % (key,))
+        found[key] = value
+    return found
+
+
+def _no_constant(name):
+    raise ValueError("%s is not a JSON number" % name)
+
+
+def _finite_float(text):
+    value = float(text)
+    if value != value or value in (float("inf"), float("-inf")):
+        raise ValueError("%s is out of range" % text)
+    return value
+
+
+def parse_json(text):
+    """Strict JSON: no duplicate keys, no NaN or Infinity (also none that overflows, such as 1e999), so every value
+    it returns can be written back to the log."""
+
+    return json.loads(text, object_pairs_hook=_unique_pairs, parse_constant=_no_constant, parse_float=_finite_float)
+
+
+def encode_record(seq, tool, args, ok=None):
+    """A log line: ``{"seq", "tool", "args"}``, plus ``"ok"`` (the craft succeeded) for a craft."""
+
+    record = {"seq": seq, "tool": tool, "args": args}
+    if tool == "craft":
+        record["ok"] = bool(ok)
+    return (json.dumps(record, ensure_ascii=True, separators=(",", ":"), allow_nan=False) + "\n").encode("ascii")
+
+
+def check_arguments(tool, args):
+    """``args`` as a log record or a command may give them to ``tool``; ValueError says what is wrong."""
+
+    if not isinstance(args, dict) or sorted(args) != sorted(ARGUMENTS[tool]):
+        raise ValueError("%s takes the arguments %s" % (tool, ", ".join(ARGUMENTS[tool]) or "none"))
+    if tool == "get_info" and (
+        not isinstance(args["items"], list) or not all(isinstance(item, str) for item in args["items"])
+    ):
+        raise ValueError("get_info takes a list of item names")
+    if tool == "finish" and not isinstance(args["message"], str):
+        raise ValueError("finish takes a message string")
+
+
+def _record(line, seq):
+    try:
+        record = parse_json(line.decode("utf-8"))
+    except (UnicodeDecodeError, ValueError, RecursionError) as exc:
+        raise LogError("record %d is not a JSON object: %s" % (seq, exc)) from None
+    if not isinstance(record, dict):
+        raise LogError("record %d is not a JSON object" % seq)
+    tool = record.get("tool")
+    if not isinstance(tool, str) or tool not in ARGUMENTS:
+        raise LogError("record %d names no tool of the game: %r" % (seq, tool))
+    keys = {"seq", "tool", "args", "ok"} if tool == "craft" else {"seq", "tool", "args"}
+    if set(record) != keys:
+        raise LogError("record %d must have exactly the keys %s" % (seq, sorted(keys)))
+    if type(record["seq"]) is not int or record["seq"] != seq:
+        raise LogError("record %d is numbered %r" % (seq, record["seq"]))
+    try:
+        check_arguments(tool, record["args"])
+    except ValueError as exc:
+        raise LogError("record %d: %s" % (seq, exc)) from None
+    if tool == "craft" and not isinstance(record["ok"], bool):
+        raise LogError("record %d: ok must be true or false" % seq)
+    return tool, record["args"], record.get("ok")
+
+
+def replay(game, data):
+    """Apply a log's records to ``game``; how many there were.  LogError at the first record the game could not
+    have written: the replay stops there.
+
+    The records are read one at a time, and those of ``get_info`` and ``view_inventory``, which change nothing, have
+    their arguments checked but their output never rebuilt, so replaying any log within the size cap takes seconds
+    and a bounded amount of memory (a ``get_info`` record can name millions of items)."""
+
+    if not data:
+        return 0
+    if not data.endswith(b"\n"):
+        raise LogError("the last record does not end with a newline")
+    seq = start = 0
+    while start < len(data):
+        end = data.index(b"\n", start)
+        seq += 1
+        if game.finished:
+            raise LogError("record %d follows finish" % seq)
+        tool, args, ok = _record(data[start:end], seq)
+        start = end + 1
+        if tool in READ_ONLY:
+            continue
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:  # arguments no command writes
+            raise LogError("record %d cannot be applied: %s: %s" % (seq, type(exc).__name__, exc)) from None
+        if tool == "craft" and text.startswith(CRAFTED) != ok:
+            claim = "succeeded" if ok else "failed"
+            raise LogError("record %d says the craft %s, but the rules give: %s" % (seq, claim, text))
+    return seq
+
+
+# ---------------------------------------------------------------------------------------------------- the command
+
+
+class UsageError(ValueError):
+    pass
+
+
+class Result:
+    """What a command printed and its exit status: 0 done, 1 a game error (a rejected craft, the episode is over),
+    2 a usage error (nothing was run or logged), 3 the task cannot be played."""
+
+    def __init__(self, code, out="", err=""):
+        self.code = code
+        self.out = out
+        self.err = err
+
+
+def parse_command(argv):
+    """``(tool, args)`` of a command line; UsageError when it is not one."""
+
+    if not argv:
+        raise UsageError("no command")
+    tool = COMMANDS.get(argv[0])
+    if tool is None:
+        raise UsageError("unknown command %r" % argv[0])
+    rest = argv[1:]
+    if tool == "craft":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("craft --json takes one JSON object")
+            args = _json_argument(rest[1])
+            if not isinstance(args, dict) or sorted(args) != ["ingredients", "target"]:
+                raise UsageError('craft --json takes {"ingredients": {...}, "target": [item, count]}')
+            return tool, args
+        if len(rest) < 2:
+            raise UsageError("craft takes TARGET COUNT INGREDIENT=N ...")
+        ingredients = {}
+        for word in rest[2:]:
+            name, sep, count = word.rpartition("=")
+            if not sep or not name:
+                raise UsageError("ingredients are INGREDIENT=N, got %r" % word)
+            if name in ingredients:
+                raise UsageError("ingredient %r is given twice" % name)
+            ingredients[name] = _integer(count, "the count of %s" % name)
+        return tool, {"ingredients": ingredients, "target": [rest[0], _integer(rest[1], "COUNT")]}
+    if tool == "get_info":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("info --json takes one JSON list")
+            items = _json_argument(rest[1])
+        else:
+            items = list(rest)
+        args = {"items": items}
+    elif tool == "view_inventory":
+        if rest:
+            raise UsageError("inventory takes no arguments")
+        args = {}
+    else:
+        if not rest:
+            raise UsageError("finish takes a MESSAGE saying what you achieved")
+        args = {"message": " ".join(rest)}
+    try:
+        check_arguments(tool, args)
+    except ValueError as exc:
+        raise UsageError(str(exc)) from None
+    return tool, args
+
+
+def _json_argument(text):
+    try:
+        return parse_json(text)
+    except (ValueError, RecursionError) as exc:
+        raise UsageError("not valid JSON: %s" % exc) from None
+
+
+def _integer(text, what):
+    try:
+        return int(text)
+    except ValueError:
+        raise UsageError("%s must be an integer, got %r" % (what, text)) from None
+
+
+def default_directory():
+    return os.environ.get("TEXTCRAFT_DIR") or os.path.dirname(os.path.abspath(__file__))
+
+
+def run(argv, directory=None, recipes=None):
+    """Run a command line against the task in ``directory`` (default ``$TEXTCRAFT_DIR``, else this file's
+    directory), with the recipes ``recipes`` (default ``$TEXTCRAFT_RECIPES``, else the directory's
+    ``recipes.json``)."""
+
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        return Result(0 if argv else 2, USAGE)
+    if argv[0] == "--version":
+        return Result(0, "textcraft %s" % VERSION)
+    try:
+        tool, args = parse_command(argv)
+    except UsageError as exc:
+        return Result(2, err="textcraft: %s\n\n%s" % (exc, USAGE))
+    directory = directory or default_directory()
+    try:
+        task = load_task(os.path.join(directory, TASK_FILE))
+        book = RecipeBook.load(recipes or os.environ.get("TEXTCRAFT_RECIPES") or os.path.join(directory, RECIPES_FILE))
+    except (OSError, ValueError, KeyError) as exc:
+        return Result(3, err="textcraft: cannot load the task: %s" % exc)
+    if task["recipes_sha256"] != book.sha256:
+        return Result(3, err="textcraft: the recipes (%s) are not the ones of this task" % book.sha256)
+    path = os.path.join(directory, LOG_FILE)
+    try:
+        fd = os.open(path, os.O_RDWR | os.O_CREAT | os.O_APPEND | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    except OSError as exc:
+        why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+        return Result(3, err="textcraft: cannot open the action log %s: %s" % (path, why))
+    try:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_EX)
+        except OSError:
+            pass  # a file system without locks: commands are not expected to overlap
+        if not stat.S_ISREG(os.fstat(fd).st_mode):
+            return Result(3, err="textcraft: the action log %s is not a regular file" % path)
+        data = _read_all(fd)
+        game = Game(book, task)
+        try:
+            seq = replay(game, data) + 1
+        except LogError as exc:
+            return Result(
+                3, err="textcraft: the action log %s does not replay (%s); the episode cannot continue" % (path, exc)
+            )
+        if game.finished:
+            return Result(
+                1, "Error: the episode is finished (textcraft finish was called); no command is accepted after it"
+            )
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:
+            return Result(2, err="textcraft: cannot run %s: %s: %s" % (tool, type(exc).__name__, exc))
+        ok = text.startswith(CRAFTED)
+        line = encode_record(seq, tool, args, ok)
+        if len(data) + len(line) > LOG_CAP_BYTES:
+            return Result(1, "Error: the action log is full (%d bytes); no command is accepted" % LOG_CAP_BYTES)
+        _write_all(fd, line)
+    finally:
+        os.close(fd)
+    return Result(1 if tool == "craft" and not ok else 0, text)
+
+
+def _read_all(fd):
+    os.lseek(fd, 0, os.SEEK_SET)
+    chunks = []
+    while True:
+        chunk = os.read(fd, 1 << 20)
+        if not chunk:
+            return b"".join(chunks)
+        chunks.append(chunk)
+
+
+def _write_all(fd, data):
+    view = memoryview(data)
+    while view:
+        view = view[os.write(fd, view) :]
+
+
+# ---------------------------------------------------------------------------------------------------- the verifier
+
+
+def read_untrusted(root, relative, cap=LOG_CAP_BYTES):
+    """The bytes of ``root/relative``, reached without following a symbolic link below ``root``; None when it does
+    not exist.  LogError when it is not a regular file, or holds more than ``cap`` bytes."""
+
+    parts = [part for part in relative.split("/") if part not in ("", ".")]
+    if not parts or ".." in parts:
+        raise ValueError("%r is not a path below the root" % relative)
+    directory = os.open(root, os.O_RDONLY | os.O_DIRECTORY | _CLOEXEC)
+    try:
+        for part in parts[:-1]:
+            try:
+                below = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW | _CLOEXEC, dir_fd=directory)
+            except FileNotFoundError:
+                return None
+            except OSError as exc:
+                raise LogError("%s on the way to the action log is not a directory (%s)" % (part, exc.strerror))
+            os.close(directory)
+            directory = below
+        try:
+            fd = os.open(parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK | _CLOEXEC, dir_fd=directory)
+        except FileNotFoundError:
+            return None
+        except OSError as exc:
+            why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+            raise LogError("cannot open the action log: %s" % why)
+    finally:
+        os.close(directory)
+    try:
+        info = os.fstat(fd)
+        if not stat.S_ISREG(info.st_mode):
+            raise LogError("the action log is not a regular file")
+        if info.st_size > cap:
+            raise LogError("the action log holds %d bytes; the limit is %d" % (info.st_size, cap))
+        chunks, total = [], 0
+        while total <= cap:
+            chunk = os.read(fd, min(1 << 20, cap + 1 - total))
+            if not chunk:
+                break
+            chunks.append(chunk)
+            total += len(chunk)
+        if total > cap:
+            raise LogError("the action log holds more than %d bytes" % cap)
+        return b"".join(chunks)
+    finally:
+        os.close(fd)
+
+
+def verify(task_path, recipes_path, root, log, out=None):
+    """Grade the log at ``root/log`` against the trusted task and recipes; the verdict (``reward`` and why).
+    Writes ``reward.json`` and ``textcraft-verdict.json`` into ``out`` when given."""
+
+    task = load_task(task_path)
+    book = RecipeBook.load(recipes_path)
+    if task["recipes_sha256"] != book.sha256:
+        raise ValueError("the verifier's recipes %s are not the task's %s" % (book.sha256, task["recipes_sha256"]))
+    game = Game(book, task)
+    verdict = {"reward": 0.0, "task": task["name"], "version": VERSION, "records": 0, "crafts": 0, "finished": False}
+    try:
+        data = read_untrusted(root, log)
+        if data is None:
+            verdict["reason"] = "no action log: no textcraft command ran"
+        else:
+            verdict["log_bytes"] = len(data)
+            verdict["records"] = replay(game, data)
+            verdict["crafts"] = game.crafts
+            verdict["finished"] = game.finished
+            if not game.finished:
+                verdict["reason"] = "the episode did not end with textcraft finish"
+            elif game.score >= 1.0:
+                verdict["reward"] = 1.0
+                verdict["reason"] = "finished with every target crafted"
+            elif game.reward_misc.get("missing_items"):
+                verdict["reason"] = "finished without every target crafted"
+                verdict["missing_items"] = game.reward_misc["missing_items"]
+            else:
+                verdict["reason"] = "finished with an empty message"
+    except LogError as exc:
+        verdict["reason"] = "the action log is not one the game wrote: %s" % exc
+    if out is not None:
+        _write_new(out, VERDICT_FILE, json.dumps(verdict, indent=1, sort_keys=True) + "\n")
+        _write_new(out, REWARD_FILE, json.dumps({"reward": verdict["reward"]}) + "\n")
+    return verdict
+
+
+def _write_new(directory, name, text):
+    """Write ``directory/name`` through a new file and a rename, so the name ends up a regular file whatever was
+    there."""
+
+    temporary = os.path.join(directory, ".%s.%d.tmp" % (name, os.getpid()))
+    fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    try:
+        _write_all(fd, text.encode("utf-8"))
+        os.fsync(fd)
+    finally:
+        os.close(fd)
+    os.replace(temporary, os.path.join(directory, name))
+
+
+def verify_main(argv):
+    parser = argparse.ArgumentParser(prog="textcraft_game.py verify", description="Grade a TextCraft action log.")
+    parser.add_argument("--task", required=True, help="the trusted task.json")
+    parser.add_argument("--recipes", required=True, help="the trusted recipes.json")
+    parser.add_argument("--root", required=True, help="the sandbox root the log path is below")
+    parser.add_argument("--log", required=True, help="the log's path below the root")
+    parser.add_argument("--out", required=True, help="the verifier's output directory (reward.json)")
+    options = parser.parse_args(argv)
+    try:
+        verdict = verify(options.task, options.recipes, options.root, options.log, options.out)
+    except (OSError, ValueError, KeyError) as exc:
+        print("textcraft verify: cannot grade: %s" % exc, file=sys.stderr)
+        return 1
+    print(
+        "reward %g: %s (%d records, %d crafts)"
+        % (verdict["reward"], verdict["reason"], verdict["records"], verdict["crafts"])
+    )
+    return 0
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv[:1] == ["verify"]:
+        return verify_main(argv[1:])
+    result = run(argv)
+    if result.out:
+        print(result.out)
+    if result.err:
+        print(result.err, file=sys.stderr)
+    return result.code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/textcraft-synth-train-easy-00615/instruction.md

@@ -0,0 +1,38 @@
+You are an agent in a crafting game. Your goal is to craft items by combining ingredients.
+You have access to an inventory of existing ingredients, which are sufficient to craft the target items; though, you may need to craft intermediate ingredients first.
+
+Note: If you already have one of the target items in your inventory, you should craft the requested number of the target on top of what you already have.
+For example, if you already have 2 wooden_pickaxes but your goal is to craft 3, your inventory should end up with 5 wooden_pickaxes.
+
+## Task
+
+Craft the following items: 3x t0_i3
+
+## Actions
+
+You act through the `textcraft` command in the shell:
+
+1. `textcraft craft TARGET TOTAL_COUNT INGREDIENT=COUNT [INGREDIENT=COUNT ...]`
+   Craft items using ingredients from your inventory.
+   - INGREDIENT=COUNT pairs: the items to consume and how many of each
+   - TARGET TOTAL_COUNT: the item to craft and its total count, which must be divisible by the recipe's result_count
+   - Example: `textcraft craft m2_i2 2 m0_i1=2 m1_i1=1`
+
+2. `textcraft info ITEM [ITEM ...]`
+   Get recipe information for items.
+   - Prints a JSON list with {"item": str, "can_craft": bool, "is_base": bool, "in_inventory": int, "crafting_depth": int, "recipes": [...]}
+   - crafting_depth indicates complexity: 0=base item, 1=direct craft, 2+=needs intermediate steps
+   - Each recipe shows {"ingredients": {...}, "result_count": int}
+   - Example: `textcraft info m2_i2 raw_m0`
+
+3. `textcraft inventory`
+   View your current inventory.
+   - Prints JSON {item_name: count}
+
+4. `textcraft finish MESSAGE`
+   Complete the task.
+   - Example: `textcraft finish "Successfully crafted all required items"`
+   - The task is graded when you finish, on what your inventory gained; no command is accepted after it, and a
+     task that never finishes counts as failed.
+
+The game keeps its state in `/app/textcraft`; change it only through the `textcraft` command.

tasks/textcraft-synth-train-easy-00615/solution/solve.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+# The reference solution of textcraft-synth-train-easy-00615: the source task's gold trajectory (4 crafts), then finish.
+set -euo pipefail
+if ! command -v textcraft >/dev/null 2>&1; then
+  # platoon's process provider runs no image, so there is no textcraft command: run the game file itself.
+  textcraft() { python3 -I "${PLATOON_SANDBOX_ROOT:-}/app/textcraft/textcraft_game.py" "$@"; }
+fi
+textcraft craft t9_i1_19 2 raw_t3=1
+textcraft craft t0_i1_10 6 raw_t9=4
+textcraft craft t8_i1 4 raw_t1=2
+textcraft craft t0_i3 4 t9_i1_19=2 t0_i1_10=4 t8_i1=4
+textcraft finish 'Crafted 3x t0_i3'

tasks/textcraft-synth-train-easy-00615/task.toml

@@ -0,0 +1,33 @@
+schema_version = "1.4"
+# The game's action log: a separate verifier receives it at the same path.
+artifacts = ["/app/textcraft/actions.jsonl"]
+
+[task]
+name = "textcraft-synth/train-easy-00615"
+description = "TextCraft-Synth: craft the following items: 3x t0_i3 (easy, crafting depth 3)"
+keywords = ["textcraft", "textcraft-synth", "crafting", "planning"]
+
+[metadata]
+environment = "textcraft-synth@1"
+split = "train"
+difficulty = "easy"
+max_depth = 3
+num_craft_steps = 4
+goal = "Craft the following items: 3x t0_i3"
+source_task_id = "textcraft_synth.train.615"
+env_task_id = "train:615"
+env_split_task_id = "train-easy:130"
+
+[verifier]
+environment_mode = "separate"
+timeout_sec = 180.0
+
+[agent]
+timeout_sec = 660.0
+
+[environment]
+network_mode = "no-network"
+cpus = 1
+memory_mb = 2048
+gpus = 0
+build_timeout_sec = 900.0

tasks/textcraft-synth-train-easy-00615/tests/Dockerfile

@@ -0,0 +1,13 @@
+# textcraft-synth-train-easy-00615: task.json sha256:efe8d61ade9146914304ab7b7b6a97a36a3c65e5fa0d699c8c399c783b66e8da
+FROM docker.io/library/python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1
+# The same image as the task's environment, so one image serves the agent and the verifier.
+RUN set -eux; \
+    printf '#!/bin/sh\nexec python3 -I /app/textcraft/textcraft_game.py "$@"\n' \
+        > /usr/local/bin/textcraft; \
+    chmod 0755 /usr/local/bin/textcraft; \
+    apt-get -o APT::Sandbox::User=root update; \
+    apt-get -o APT::Sandbox::User=root install -y --no-install-recommends tmux; \
+    rm -rf /var/lib/apt/lists/*
+# The verifier's trusted copies of the grader, the game, the recipes and the task.
+WORKDIR /app
+COPY test.sh textcraft_game.py recipes.json task.json /tests/

tasks/textcraft-synth-train-easy-00615/tests/task.json

@@ -0,0 +1,16 @@
+{
+ "format": "textcraft-task/1",
+ "name": "textcraft-synth-train-easy-00615",
+ "world": "textcraft-synth",
+ "goal": "Craft the following items: 3x t0_i3",
+ "target_items": {
+  "t0_i3": 3
+ },
+ "initial_inventory": {
+  "raw_t3": 3,
+  "raw_t9": 16,
+  "raw_t1": 7,
+  "raw_a2": 2
+ },
+ "recipes_sha256": "a020eec273337c66b35c0fc487664e35c44da65ad18e9afffe6a4c25af949f10"
+}

tasks/textcraft-synth-train-easy-00615/tests/test.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# Grade a TextCraft episode: replay the agent's action log (/app/textcraft/actions.jsonl) from the task's starting
+# inventory with the game's rules, using this directory's own copies of the game, the recipes and the task.  The
+# reward is 1 only when the log is an episode the rules allow that ends in `textcraft finish` with every target
+# crafted (the verdict goes to textcraft-verdict.json).  It runs in the agent's container (a shared verifier) or in a
+# separate verifier that received the log as an artifact.
+# PLATOON_SANDBOX_ROOT: platoon's process provider runs this on the host, with the sandbox's files below that
+# directory; sandboxes leave it unset.
+set -u
+root="${PLATOON_SANDBOX_ROOT:-}"
+tests="$root/tests"
+out="$root/logs/verifier"
+mkdir -p "$out"
+# A fresh verdict: nothing the agent may have left in the verifier's directory counts.
+rm -rf -- "$out/reward.json" "$out/reward.txt" "$out/textcraft-verdict.json"
+exec python3 -I "$tests/textcraft_game.py" verify --task "$tests/task.json" --recipes "$tests/recipes.json" \
+  --root "$root/" --log app/textcraft/actions.jsonl --out "$out"

tasks/textcraft-synth-train-easy-00615/tests/textcraft_game.py

@@ -0,0 +1,756 @@
+"""TextCraft in a container: the ``textcraft`` command of a Harbor task, and the verifier that grades it.
+
+This one file is the whole game.  It needs Python 3.8 or later and its standard library only, and it never imports
+platoon: the exporter (``python -m platoon.textcraft.harbor export``) copies it into every task as
+``textcraft_game.py``, into ``environment/`` (the container gets it at ``/app/textcraft/textcraft_game.py``, which
+the image's ``textcraft`` command runs) and into ``tests/`` for the verifier.  It reproduces platoon's TextCraft
+environments (``platoon.textcraft.env``): the same four tools with the same arguments, the same observation text
+and the same success rule.
+
+=========================================  ===================  ===============================================
+command                                    environment tool     prints
+=========================================  ===================  ===============================================
+``textcraft craft TARGET COUNT ING=N ...``  ``craft``            ``Successfully crafted ...`` or ``Error: ...``
+``textcraft info ITEM ...``                 ``get_info``         the recipe information, as JSON
+``textcraft inventory``                     ``view_inventory``   the inventory, as JSON
+``textcraft finish MESSAGE``                ``finish``           the message; the episode ends
+=========================================  ===================  ===============================================
+
+``craft --json '{"ingredients": {...}, "target": [item, count]}'`` and ``info --json '[item, ...]'`` take a tool's
+arguments as JSON values, the way a tool call passes them.
+
+**State.**  ``$TEXTCRAFT_DIR`` (default: this file's directory, ``/app/textcraft`` in a task's container) holds the
+task (``task.json``: goal, targets, starting inventory), the world's recipes (``recipes.json``, or
+``$TEXTCRAFT_RECIPES``) and the action log (``actions.jsonl``).  The log is the state: under an exclusive lock,
+every command replays the log from the starting inventory, runs, and appends its own record (``{"seq", "tool",
+"args"}``, plus ``"ok"`` for a craft).  Nothing is accepted after ``finish``, or once the log no longer replays.
+
+**Grading** (``python3 textcraft_game.py verify``, from the task's ``tests/test.sh``) replays the log with trusted
+copies of the task and the recipes.  The reward is 1 when the log is an episode the rules allow that ends in
+``finish`` with a message, and the inventory then holds every target count on top of the starting inventory (the
+environment's rule); otherwise it is 0.  The log must be a regular file of at most 32 MiB, reached without a
+symbolic link below the sandbox root.  A record that does not parse, breaks the record format or the numbering,
+follows ``finish``, or claims a craft outcome the rules do not give ends the replay with reward 0: only a log the
+command could have written earns a reward.  A craft the rules reject, recorded as rejected, changes nothing, as in
+the environment.
+"""
+
+from __future__ import annotations
+
+import argparse
+import errno
+import fcntl
+import hashlib
+import json
+import os
+import stat
+import sys
+
+VERSION = "1.0"
+TASK_FORMAT = "textcraft-task/1"
+RECIPES_FORMAT = "textcraft-recipes/1"
+TASK_FILE = "task.json"
+LOG_FILE = "actions.jsonl"
+RECIPES_FILE = "recipes.json"
+REWARD_FILE = "reward.json"
+VERDICT_FILE = "textcraft-verdict.json"
+LOG_CAP_BYTES = 32 * 1024 * 1024
+CRAFTED = "Successfully crafted"
+# The environment's tools and their arguments, as a log record names them.
+ARGUMENTS = {"craft": ("ingredients", "target"), "get_info": ("items",), "view_inventory": (), "finish": ("message",)}
+READ_ONLY = frozenset({"get_info", "view_inventory"})  # tools that change nothing
+COMMANDS = {
+    "craft": "craft",
+    "info": "get_info",
+    "get_info": "get_info",
+    "inventory": "view_inventory",
+    "view_inventory": "view_inventory",
+    "finish": "finish",
+}
+_CLOEXEC = getattr(os, "O_CLOEXEC", 0)
+
+USAGE = """\
+usage: textcraft COMMAND [ARGUMENTS]
+
+Play the TextCraft task in $TEXTCRAFT_DIR (default /app/textcraft, the game's directory).
+
+  textcraft craft TARGET COUNT INGREDIENT=N [INGREDIENT=N ...]
+      Craft COUNT of TARGET from exactly these ingredients.  COUNT must be divisible by the recipe's
+      result_count; each ingredient's N is its recipe count times COUNT / result_count.
+      Example: textcraft craft m2_i2 2 m0_i1=2 m1_i1=1
+  textcraft info ITEM [ITEM ...]
+      Recipe information for the items, as a JSON list.
+  textcraft inventory
+      Your current inventory, as JSON {item_name: count}.
+  textcraft finish MESSAGE
+      Complete the task with a message saying what you achieved.  The task is graded on what your
+      inventory gained; no command is accepted after it.
+
+craft --json '{"ingredients": {...}, "target": [item, count]}' and info --json '[item, ...]' take the
+arguments as JSON.  get_info and view_inventory are other names for info and inventory.
+"""
+
+
+# ---------------------------------------------------------------------------------------------------- the world
+
+
+class Recipe:
+    __slots__ = ("result_count", "ingredients")
+
+    def __init__(self, result_count, ingredients):
+        self.result_count = result_count
+        self.ingredients = ingredients  # {item or "tag:<name>": count}, in the recipe's order
+
+
+class RecipeBook:
+    """A world's recipes (``recipes.json``), with the lookups of platoon's recipe databases.
+
+    The file lists each craftable item's recipes (ingredients as ``[name, count]`` pairs, in order), the base items,
+    every item's crafting depth (0 for items it does not list) and the items each ``tag:<name>`` ingredient accepts.
+    """
+
+    def __init__(self, data, sha256=None):
+        if not isinstance(data, dict) or data.get("format") != RECIPES_FORMAT:
+            raise ValueError("not a %s file" % RECIPES_FORMAT)
+        self.name = data["name"]
+        self.sha256 = sha256
+        self.recipes = {
+            item: [
+                Recipe(recipe["result_count"], {name: count for name, count in recipe["ingredients"]})
+                for recipe in recipes
+            ]
+            for item, recipes in data["recipes"].items()
+        }
+        self.base_items = frozenset(data["base_items"])
+        self.depths = dict(data["depths"])
+        self.tags = {tag: list(items) for tag, items in data["tags"].items()}
+
+    @classmethod
+    def load(cls, path):
+        with open(path, "rb") as handle:
+            raw = handle.read()
+        return cls(json.loads(raw.decode("utf-8")), sha256=hashlib.sha256(raw).hexdigest())
+
+    def get_recipes_for_item(self, item):
+        return self.recipes.get(item, [])
+
+    def can_craft(self, item):
+        return item in self.recipes
+
+    def is_base_item(self, item):
+        return item in self.base_items
+
+    def get_crafting_depth(self, item):
+        return self.depths.get(item, 0)
+
+    def get_items_for_tag(self, tag):
+        return list(self.tags.get(tag, []))
+
+
+def load_task(path):
+    """A task file (``task.json``): its goal, targets and starting inventory, and its recipes' SHA-256."""
+
+    with open(path, "rb") as handle:
+        task = json.loads(handle.read().decode("utf-8"))
+    if not isinstance(task, dict) or task.get("format") != TASK_FORMAT:
+        raise ValueError("%s is not a %s file" % (path, TASK_FORMAT))
+    for key in ("name", "goal", "target_items", "initial_inventory", "recipes_sha256"):
+        if key not in task:
+            raise ValueError("%s has no %r" % (path, key))
+    return task
+
+
+# ---------------------------------------------------------------------------------------------------- the game
+
+
+class Game:
+    """One episode: platoon's ``TextCraftEnvironment`` tools over an inventory, its rules and messages unchanged."""
+
+    def __init__(self, book, task):
+        self.book = book
+        self.goal = task["goal"]
+        self.target_items = dict(task["target_items"])
+        self.inventory = dict(task["initial_inventory"])
+        self.initial_inventory = dict(self.inventory)
+        self.finished = False
+        self.score = 0.0
+        self.reward_misc = {}
+        self.crafts = 0  # successful crafts
+
+    def call(self, tool, args):
+        """Run a tool with its arguments (the JSON values a tool call carries); the observation text it returns."""
+
+        if tool == "craft":
+            text = self.craft(args["ingredients"], args["target"])
+            self.crafts += text.startswith(CRAFTED)
+            return text
+        if tool == "get_info":
+            return json.dumps(self.get_info(args["items"]))
+        if tool == "view_inventory":
+            return json.dumps(dict(self.inventory))
+        if tool == "finish":
+            self.score, self.reward_misc = self.evaluate(args["message"])
+            self.finished = True
+            return args["message"]
+        raise ValueError("unknown tool %r" % (tool,))
+
+    def craft(self, ingredients, target):
+        """``TextCraftEnvironment._craft``: the same checks in the same order, with the same messages."""
+
+        if not isinstance(ingredients, dict):
+            return f"Error: ingredients must be a dict, got {type(ingredients).__name__}"
+        if not isinstance(target, (tuple, list)) or len(target) != 2:
+            return "Error: target must be a tuple of (item_name, count)"
+        target_item, target_count = target
+        if not isinstance(target_item, str):
+            return f"Error: target item must be a string, got {type(target_item).__name__}"
+        if not isinstance(target_count, int):
+            return f"Error: target count must be an int, got {type(target_count).__name__}"
+        if target_count <= 0:
+            return f"Error: target count must be positive, got {target_count}"
+        for ing_item, ing_count in ingredients.items():
+            if not isinstance(ing_item, str):
+                return f"Error: ingredient name must be a string, got {type(ing_item).__name__}"
+            if not isinstance(ing_count, int):
+                return f"Error: ingredient count for {ing_item} must be an int, got {type(ing_count).__name__}"
+            if ing_count <= 0:
+                return f"Error: ingredient count for {ing_item} must be positive, got {ing_count}"
+
+        book = self.book
+        recipes = book.get_recipes_for_item(target_item)
+        if not recipes:
+            return f"Error: No recipe found for {target_item}"
+
+        errors = []
+        for recipe_idx, recipe in enumerate(recipes):
+            if target_count % recipe.result_count != 0:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Target count {target_count} is not divisible "
+                    f"by recipe result count {recipe.result_count}"
+                )
+                continue
+            num_crafts = target_count // recipe.result_count
+
+            ingredient_mapping = {}  # recipe ingredient (or tag) -> provided item
+            recipe_error = None
+            for recipe_ing, recipe_count in recipe.ingredients.items():
+                total_required = recipe_count * num_crafts
+                if recipe_ing.startswith("tag:"):
+                    satisfying_items = book.get_items_for_tag(recipe_ing.replace("tag:", ""))
+                    provided = next(
+                        (
+                            item
+                            for item, count in ingredients.items()
+                            if item in satisfying_items and count == total_required
+                        ),
+                        None,
+                    )
+                    if provided is None:
+                        recipe_error = f"No ingredient provided for {recipe_ing}. Expected one of: {satisfying_items}"
+                        break
+                    ingredient_mapping[recipe_ing] = provided
+                else:
+                    if recipe_ing not in ingredients:
+                        recipe_error = f"Missing required ingredient {recipe_ing}"
+                        break
+                    if ingredients[recipe_ing] != total_required:
+                        recipe_error = (
+                            f"Wrong amount of {recipe_ing}. Need {total_required}, provided {ingredients[recipe_ing]}"
+                        )
+                        break
+                    ingredient_mapping[recipe_ing] = recipe_ing
+            if recipe_error:
+                errors.append(f"Recipe {recipe_idx + 1}: {recipe_error}")
+                continue
+
+            extra_ingredients = [item for item in ingredients if item not in ingredient_mapping.values()]
+            if extra_ingredients:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Extra ingredients not required: {', '.join(extra_ingredients)}"
+                )
+                continue
+
+            missing = []
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                required = recipe.ingredients[recipe_ing] * num_crafts
+                available = self.inventory.get(provided_ing, 0)
+                if available < required:
+                    missing.append(f"{provided_ing}: need {required}, have {available}")
+            if missing:
+                errors.append(f"Recipe {recipe_idx + 1}: Insufficient ingredients in inventory: {', '.join(missing)}")
+                continue
+
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                self.inventory[provided_ing] -= recipe.ingredients[recipe_ing] * num_crafts
+                if self.inventory[provided_ing] <= 0:
+                    del self.inventory[provided_ing]
+            crafted_count = recipe.result_count * num_crafts
+            self.inventory[target_item] = self.inventory.get(target_item, 0) + crafted_count
+            return f"Successfully crafted {crafted_count} {target_item}(s)"
+
+        return f"Error: All {len(recipes)} recipe(s) failed for {target_item}. Errors:\n" + "\n".join(errors)
+
+    def get_info(self, items):
+        """``TextCraftEnvironment._get_info``."""
+
+        book = self.book
+        results = []
+        for item in items:
+            info = {
+                "item": item,
+                "can_craft": book.can_craft(item),
+                "is_base": book.is_base_item(item),
+                "in_inventory": self.inventory.get(item, 0),
+                "crafting_depth": book.get_crafting_depth(item),
+                "recipes": [],
+            }
+            if info["can_craft"]:
+                for recipe in book.get_recipes_for_item(item):
+                    expanded = {}
+                    for ing, count in recipe.ingredients.items():
+                        if ing.startswith("tag:"):
+                            expanded[ing] = {"count": count, "use_one_of": book.get_items_for_tag(ing[4:])}
+                        else:
+                            expanded[ing] = count
+                    info["recipes"].append({"ingredients": expanded, "result_count": recipe.result_count})
+            results.append(info)
+        return results
+
+    def evaluate(self, finish_message):
+        """``TextCraftEnvironment.evaluate``: success when the inventory gained every target count and the finish
+        message is not empty."""
+
+        reward_misc = {}
+        score = 0.0
+        if finish_message:
+            if not self.target_items:
+                return 0.0, {"success": False, "error": "No target items defined in task", "reward/success": 0.0}
+            missing = {
+                item: required - (self.inventory.get(item, 0) - self.initial_inventory.get(item, 0))
+                for item, required in self.target_items.items()
+                if self.inventory.get(item, 0) - self.initial_inventory.get(item, 0) < required
+            }
+            reward_misc["success"] = not missing
+            if missing:
+                reward_misc["missing_items"] = missing
+            else:
+                score = 1.0
+            reward_misc["target_items"] = dict(self.target_items)
+            reward_misc["initial_inventory"] = dict(self.initial_inventory)
+            reward_misc["final_inventory"] = dict(self.inventory)
+        else:
+            reward_misc["success"] = False
+            reward_misc["error"] = "Episode ended without calling finish() - likely timeout or max steps reached"
+        reward_misc["reward/success"] = score
+        return score, reward_misc
+
+
+# ---------------------------------------------------------------------------------------------------- the log
+
+
+class LogError(ValueError):
+    """An action log the game could not have written: its replay stops there."""
+
+
+def _unique_pairs(pairs):
+    found = {}
+    for key, value in pairs:
+        if key in found:
+            raise ValueError("duplicate key %r" % (key,))
+        found[key] = value
+    return found
+
+
+def _no_constant(name):
+    raise ValueError("%s is not a JSON number" % name)
+
+
+def _finite_float(text):
+    value = float(text)
+    if value != value or value in (float("inf"), float("-inf")):
+        raise ValueError("%s is out of range" % text)
+    return value
+
+
+def parse_json(text):
+    """Strict JSON: no duplicate keys, no NaN or Infinity (also none that overflows, such as 1e999), so every value
+    it returns can be written back to the log."""
+
+    return json.loads(text, object_pairs_hook=_unique_pairs, parse_constant=_no_constant, parse_float=_finite_float)
+
+
+def encode_record(seq, tool, args, ok=None):
+    """A log line: ``{"seq", "tool", "args"}``, plus ``"ok"`` (the craft succeeded) for a craft."""
+
+    record = {"seq": seq, "tool": tool, "args": args}
+    if tool == "craft":
+        record["ok"] = bool(ok)
+    return (json.dumps(record, ensure_ascii=True, separators=(",", ":"), allow_nan=False) + "\n").encode("ascii")
+
+
+def check_arguments(tool, args):
+    """``args`` as a log record or a command may give them to ``tool``; ValueError says what is wrong."""
+
+    if not isinstance(args, dict) or sorted(args) != sorted(ARGUMENTS[tool]):
+        raise ValueError("%s takes the arguments %s" % (tool, ", ".join(ARGUMENTS[tool]) or "none"))
+    if tool == "get_info" and (
+        not isinstance(args["items"], list) or not all(isinstance(item, str) for item in args["items"])
+    ):
+        raise ValueError("get_info takes a list of item names")
+    if tool == "finish" and not isinstance(args["message"], str):
+        raise ValueError("finish takes a message string")
+
+
+def _record(line, seq):
+    try:
+        record = parse_json(line.decode("utf-8"))
+    except (UnicodeDecodeError, ValueError, RecursionError) as exc:
+        raise LogError("record %d is not a JSON object: %s" % (seq, exc)) from None
+    if not isinstance(record, dict):
+        raise LogError("record %d is not a JSON object" % seq)
+    tool = record.get("tool")
+    if not isinstance(tool, str) or tool not in ARGUMENTS:
+        raise LogError("record %d names no tool of the game: %r" % (seq, tool))
+    keys = {"seq", "tool", "args", "ok"} if tool == "craft" else {"seq", "tool", "args"}
+    if set(record) != keys:
+        raise LogError("record %d must have exactly the keys %s" % (seq, sorted(keys)))
+    if type(record["seq"]) is not int or record["seq"] != seq:
+        raise LogError("record %d is numbered %r" % (seq, record["seq"]))
+    try:
+        check_arguments(tool, record["args"])
+    except ValueError as exc:
+        raise LogError("record %d: %s" % (seq, exc)) from None
+    if tool == "craft" and not isinstance(record["ok"], bool):
+        raise LogError("record %d: ok must be true or false" % seq)
+    return tool, record["args"], record.get("ok")
+
+
+def replay(game, data):
+    """Apply a log's records to ``game``; how many there were.  LogError at the first record the game could not
+    have written: the replay stops there.
+
+    The records are read one at a time, and those of ``get_info`` and ``view_inventory``, which change nothing, have
+    their arguments checked but their output never rebuilt, so replaying any log within the size cap takes seconds
+    and a bounded amount of memory (a ``get_info`` record can name millions of items)."""
+
+    if not data:
+        return 0
+    if not data.endswith(b"\n"):
+        raise LogError("the last record does not end with a newline")
+    seq = start = 0
+    while start < len(data):
+        end = data.index(b"\n", start)
+        seq += 1
+        if game.finished:
+            raise LogError("record %d follows finish" % seq)
+        tool, args, ok = _record(data[start:end], seq)
+        start = end + 1
+        if tool in READ_ONLY:
+            continue
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:  # arguments no command writes
+            raise LogError("record %d cannot be applied: %s: %s" % (seq, type(exc).__name__, exc)) from None
+        if tool == "craft" and text.startswith(CRAFTED) != ok:
+            claim = "succeeded" if ok else "failed"
+            raise LogError("record %d says the craft %s, but the rules give: %s" % (seq, claim, text))
+    return seq
+
+
+# ---------------------------------------------------------------------------------------------------- the command
+
+
+class UsageError(ValueError):
+    pass
+
+
+class Result:
+    """What a command printed and its exit status: 0 done, 1 a game error (a rejected craft, the episode is over),
+    2 a usage error (nothing was run or logged), 3 the task cannot be played."""
+
+    def __init__(self, code, out="", err=""):
+        self.code = code
+        self.out = out
+        self.err = err
+
+
+def parse_command(argv):
+    """``(tool, args)`` of a command line; UsageError when it is not one."""
+
+    if not argv:
+        raise UsageError("no command")
+    tool = COMMANDS.get(argv[0])
+    if tool is None:
+        raise UsageError("unknown command %r" % argv[0])
+    rest = argv[1:]
+    if tool == "craft":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("craft --json takes one JSON object")
+            args = _json_argument(rest[1])
+            if not isinstance(args, dict) or sorted(args) != ["ingredients", "target"]:
+                raise UsageError('craft --json takes {"ingredients": {...}, "target": [item, count]}')
+            return tool, args
+        if len(rest) < 2:
+            raise UsageError("craft takes TARGET COUNT INGREDIENT=N ...")
+        ingredients = {}
+        for word in rest[2:]:
+            name, sep, count = word.rpartition("=")
+            if not sep or not name:
+                raise UsageError("ingredients are INGREDIENT=N, got %r" % word)
+            if name in ingredients:
+                raise UsageError("ingredient %r is given twice" % name)
+            ingredients[name] = _integer(count, "the count of %s" % name)
+        return tool, {"ingredients": ingredients, "target": [rest[0], _integer(rest[1], "COUNT")]}
+    if tool == "get_info":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("info --json takes one JSON list")
+            items = _json_argument(rest[1])
+        else:
+            items = list(rest)
+        args = {"items": items}
+    elif tool == "view_inventory":
+        if rest:
+            raise UsageError("inventory takes no arguments")
+        args = {}
+    else:
+        if not rest:
+            raise UsageError("finish takes a MESSAGE saying what you achieved")
+        args = {"message": " ".join(rest)}
+    try:
+        check_arguments(tool, args)
+    except ValueError as exc:
+        raise UsageError(str(exc)) from None
+    return tool, args
+
+
+def _json_argument(text):
+    try:
+        return parse_json(text)
+    except (ValueError, RecursionError) as exc:
+        raise UsageError("not valid JSON: %s" % exc) from None
+
+
+def _integer(text, what):
+    try:
+        return int(text)
+    except ValueError:
+        raise UsageError("%s must be an integer, got %r" % (what, text)) from None
+
+
+def default_directory():
+    return os.environ.get("TEXTCRAFT_DIR") or os.path.dirname(os.path.abspath(__file__))
+
+
+def run(argv, directory=None, recipes=None):
+    """Run a command line against the task in ``directory`` (default ``$TEXTCRAFT_DIR``, else this file's
+    directory), with the recipes ``recipes`` (default ``$TEXTCRAFT_RECIPES``, else the directory's
+    ``recipes.json``)."""
+
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        return Result(0 if argv else 2, USAGE)
+    if argv[0] == "--version":
+        return Result(0, "textcraft %s" % VERSION)
+    try:
+        tool, args = parse_command(argv)
+    except UsageError as exc:
+        return Result(2, err="textcraft: %s\n\n%s" % (exc, USAGE))
+    directory = directory or default_directory()
+    try:
+        task = load_task(os.path.join(directory, TASK_FILE))
+        book = RecipeBook.load(recipes or os.environ.get("TEXTCRAFT_RECIPES") or os.path.join(directory, RECIPES_FILE))
+    except (OSError, ValueError, KeyError) as exc:
+        return Result(3, err="textcraft: cannot load the task: %s" % exc)
+    if task["recipes_sha256"] != book.sha256:
+        return Result(3, err="textcraft: the recipes (%s) are not the ones of this task" % book.sha256)
+    path = os.path.join(directory, LOG_FILE)
+    try:
+        fd = os.open(path, os.O_RDWR | os.O_CREAT | os.O_APPEND | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    except OSError as exc:
+        why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+        return Result(3, err="textcraft: cannot open the action log %s: %s" % (path, why))
+    try:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_EX)
+        except OSError:
+            pass  # a file system without locks: commands are not expected to overlap
+        if not stat.S_ISREG(os.fstat(fd).st_mode):
+            return Result(3, err="textcraft: the action log %s is not a regular file" % path)
+        data = _read_all(fd)
+        game = Game(book, task)
+        try:
+            seq = replay(game, data) + 1
+        except LogError as exc:
+            return Result(
+                3, err="textcraft: the action log %s does not replay (%s); the episode cannot continue" % (path, exc)
+            )
+        if game.finished:
+            return Result(
+                1, "Error: the episode is finished (textcraft finish was called); no command is accepted after it"
+            )
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:
+            return Result(2, err="textcraft: cannot run %s: %s: %s" % (tool, type(exc).__name__, exc))
+        ok = text.startswith(CRAFTED)
+        line = encode_record(seq, tool, args, ok)
+        if len(data) + len(line) > LOG_CAP_BYTES:
+            return Result(1, "Error: the action log is full (%d bytes); no command is accepted" % LOG_CAP_BYTES)
+        _write_all(fd, line)
+    finally:
+        os.close(fd)
+    return Result(1 if tool == "craft" and not ok else 0, text)
+
+
+def _read_all(fd):
+    os.lseek(fd, 0, os.SEEK_SET)
+    chunks = []
+    while True:
+        chunk = os.read(fd, 1 << 20)
+        if not chunk:
+            return b"".join(chunks)
+        chunks.append(chunk)
+
+
+def _write_all(fd, data):
+    view = memoryview(data)
+    while view:
+        view = view[os.write(fd, view) :]
+
+
+# ---------------------------------------------------------------------------------------------------- the verifier
+
+
+def read_untrusted(root, relative, cap=LOG_CAP_BYTES):
+    """The bytes of ``root/relative``, reached without following a symbolic link below ``root``; None when it does
+    not exist.  LogError when it is not a regular file, or holds more than ``cap`` bytes."""
+
+    parts = [part for part in relative.split("/") if part not in ("", ".")]
+    if not parts or ".." in parts:
+        raise ValueError("%r is not a path below the root" % relative)
+    directory = os.open(root, os.O_RDONLY | os.O_DIRECTORY | _CLOEXEC)
+    try:
+        for part in parts[:-1]:
+            try:
+                below = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW | _CLOEXEC, dir_fd=directory)
+            except FileNotFoundError:
+                return None
+            except OSError as exc:
+                raise LogError("%s on the way to the action log is not a directory (%s)" % (part, exc.strerror))
+            os.close(directory)
+            directory = below
+        try:
+            fd = os.open(parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK | _CLOEXEC, dir_fd=directory)
+        except FileNotFoundError:
+            return None
+        except OSError as exc:
+            why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+            raise LogError("cannot open the action log: %s" % why)
+    finally:
+        os.close(directory)
+    try:
+        info = os.fstat(fd)
+        if not stat.S_ISREG(info.st_mode):
+            raise LogError("the action log is not a regular file")
+        if info.st_size > cap:
+            raise LogError("the action log holds %d bytes; the limit is %d" % (info.st_size, cap))
+        chunks, total = [], 0
+        while total <= cap:
+            chunk = os.read(fd, min(1 << 20, cap + 1 - total))
+            if not chunk:
+                break
+            chunks.append(chunk)
+            total += len(chunk)
+        if total > cap:
+            raise LogError("the action log holds more than %d bytes" % cap)
+        return b"".join(chunks)
+    finally:
+        os.close(fd)
+
+
+def verify(task_path, recipes_path, root, log, out=None):
+    """Grade the log at ``root/log`` against the trusted task and recipes; the verdict (``reward`` and why).
+    Writes ``reward.json`` and ``textcraft-verdict.json`` into ``out`` when given."""
+
+    task = load_task(task_path)
+    book = RecipeBook.load(recipes_path)
+    if task["recipes_sha256"] != book.sha256:
+        raise ValueError("the verifier's recipes %s are not the task's %s" % (book.sha256, task["recipes_sha256"]))
+    game = Game(book, task)
+    verdict = {"reward": 0.0, "task": task["name"], "version": VERSION, "records": 0, "crafts": 0, "finished": False}
+    try:
+        data = read_untrusted(root, log)
+        if data is None:
+            verdict["reason"] = "no action log: no textcraft command ran"
+        else:
+            verdict["log_bytes"] = len(data)
+            verdict["records"] = replay(game, data)
+            verdict["crafts"] = game.crafts
+            verdict["finished"] = game.finished
+            if not game.finished:
+                verdict["reason"] = "the episode did not end with textcraft finish"
+            elif game.score >= 1.0:
+                verdict["reward"] = 1.0
+                verdict["reason"] = "finished with every target crafted"
+            elif game.reward_misc.get("missing_items"):
+                verdict["reason"] = "finished without every target crafted"
+                verdict["missing_items"] = game.reward_misc["missing_items"]
+            else:
+                verdict["reason"] = "finished with an empty message"
+    except LogError as exc:
+        verdict["reason"] = "the action log is not one the game wrote: %s" % exc
+    if out is not None:
+        _write_new(out, VERDICT_FILE, json.dumps(verdict, indent=1, sort_keys=True) + "\n")
+        _write_new(out, REWARD_FILE, json.dumps({"reward": verdict["reward"]}) + "\n")
+    return verdict
+
+
+def _write_new(directory, name, text):
+    """Write ``directory/name`` through a new file and a rename, so the name ends up a regular file whatever was
+    there."""
+
+    temporary = os.path.join(directory, ".%s.%d.tmp" % (name, os.getpid()))
+    fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    try:
+        _write_all(fd, text.encode("utf-8"))
+        os.fsync(fd)
+    finally:
+        os.close(fd)
+    os.replace(temporary, os.path.join(directory, name))
+
+
+def verify_main(argv):
+    parser = argparse.ArgumentParser(prog="textcraft_game.py verify", description="Grade a TextCraft action log.")
+    parser.add_argument("--task", required=True, help="the trusted task.json")
+    parser.add_argument("--recipes", required=True, help="the trusted recipes.json")
+    parser.add_argument("--root", required=True, help="the sandbox root the log path is below")
+    parser.add_argument("--log", required=True, help="the log's path below the root")
+    parser.add_argument("--out", required=True, help="the verifier's output directory (reward.json)")
+    options = parser.parse_args(argv)
+    try:
+        verdict = verify(options.task, options.recipes, options.root, options.log, options.out)
+    except (OSError, ValueError, KeyError) as exc:
+        print("textcraft verify: cannot grade: %s" % exc, file=sys.stderr)
+        return 1
+    print(
+        "reward %g: %s (%d records, %d crafts)"
+        % (verdict["reward"], verdict["reason"], verdict["records"], verdict["crafts"])
+    )
+    return 0
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv[:1] == ["verify"]:
+        return verify_main(argv[1:])
+    result = run(argv)
+    if result.out:
+        print(result.out)
+    if result.err:
+        print(result.err, file=sys.stderr)
+    return result.code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/textcraft-synth-train-easy-00617/environment/Dockerfile

@@ -0,0 +1,17 @@
+# textcraft-synth-train-easy-00617: task.json sha256:fbfd9cadd4cb0347a5fb736799e60675d0ca012110741de9f6f6fecbc5e46faa
+FROM docker.io/library/python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1
+# The image is the same for every task (and for the verifier): Python, tmux for terminal agents, and the
+# `textcraft` command, which runs the game file below.
+RUN set -eux; \
+    printf '#!/bin/sh\nexec python3 -I /app/textcraft/textcraft_game.py "$@"\n' \
+        > /usr/local/bin/textcraft; \
+    chmod 0755 /usr/local/bin/textcraft; \
+    apt-get -o APT::Sandbox::User=root update; \
+    apt-get -o APT::Sandbox::User=root install -y --no-install-recommends tmux; \
+    rm -rf /var/lib/apt/lists/*
+# The game and the world's recipes (the same in every task), then this task's goal and starting inventory.  The
+# game keeps its action log next to them.
+WORKDIR /app
+ENV TEXTCRAFT_DIR=/app/textcraft
+COPY textcraft_game.py recipes.json /app/textcraft/
+COPY task.json /app/textcraft/

tasks/textcraft-synth-train-easy-00617/environment/task.json

@@ -0,0 +1,15 @@
+{
+ "format": "textcraft-task/1",
+ "name": "textcraft-synth-train-easy-00617",
+ "world": "textcraft-synth",
+ "goal": "Craft the following items: 1x c0_i2_20",
+ "target_items": {
+  "c0_i2_20": 1
+ },
+ "initial_inventory": {
+  "c4_ore": 2,
+  "c3_ore": 2,
+  "c7_ore": 5
+ },
+ "recipes_sha256": "a020eec273337c66b35c0fc487664e35c44da65ad18e9afffe6a4c25af949f10"
+}

tasks/textcraft-synth-train-easy-00617/environment/textcraft_game.py

@@ -0,0 +1,756 @@
+"""TextCraft in a container: the ``textcraft`` command of a Harbor task, and the verifier that grades it.
+
+This one file is the whole game.  It needs Python 3.8 or later and its standard library only, and it never imports
+platoon: the exporter (``python -m platoon.textcraft.harbor export``) copies it into every task as
+``textcraft_game.py``, into ``environment/`` (the container gets it at ``/app/textcraft/textcraft_game.py``, which
+the image's ``textcraft`` command runs) and into ``tests/`` for the verifier.  It reproduces platoon's TextCraft
+environments (``platoon.textcraft.env``): the same four tools with the same arguments, the same observation text
+and the same success rule.
+
+=========================================  ===================  ===============================================
+command                                    environment tool     prints
+=========================================  ===================  ===============================================
+``textcraft craft TARGET COUNT ING=N ...``  ``craft``            ``Successfully crafted ...`` or ``Error: ...``
+``textcraft info ITEM ...``                 ``get_info``         the recipe information, as JSON
+``textcraft inventory``                     ``view_inventory``   the inventory, as JSON
+``textcraft finish MESSAGE``                ``finish``           the message; the episode ends
+=========================================  ===================  ===============================================
+
+``craft --json '{"ingredients": {...}, "target": [item, count]}'`` and ``info --json '[item, ...]'`` take a tool's
+arguments as JSON values, the way a tool call passes them.
+
+**State.**  ``$TEXTCRAFT_DIR`` (default: this file's directory, ``/app/textcraft`` in a task's container) holds the
+task (``task.json``: goal, targets, starting inventory), the world's recipes (``recipes.json``, or
+``$TEXTCRAFT_RECIPES``) and the action log (``actions.jsonl``).  The log is the state: under an exclusive lock,
+every command replays the log from the starting inventory, runs, and appends its own record (``{"seq", "tool",
+"args"}``, plus ``"ok"`` for a craft).  Nothing is accepted after ``finish``, or once the log no longer replays.
+
+**Grading** (``python3 textcraft_game.py verify``, from the task's ``tests/test.sh``) replays the log with trusted
+copies of the task and the recipes.  The reward is 1 when the log is an episode the rules allow that ends in
+``finish`` with a message, and the inventory then holds every target count on top of the starting inventory (the
+environment's rule); otherwise it is 0.  The log must be a regular file of at most 32 MiB, reached without a
+symbolic link below the sandbox root.  A record that does not parse, breaks the record format or the numbering,
+follows ``finish``, or claims a craft outcome the rules do not give ends the replay with reward 0: only a log the
+command could have written earns a reward.  A craft the rules reject, recorded as rejected, changes nothing, as in
+the environment.
+"""
+
+from __future__ import annotations
+
+import argparse
+import errno
+import fcntl
+import hashlib
+import json
+import os
+import stat
+import sys
+
+VERSION = "1.0"
+TASK_FORMAT = "textcraft-task/1"
+RECIPES_FORMAT = "textcraft-recipes/1"
+TASK_FILE = "task.json"
+LOG_FILE = "actions.jsonl"
+RECIPES_FILE = "recipes.json"
+REWARD_FILE = "reward.json"
+VERDICT_FILE = "textcraft-verdict.json"
+LOG_CAP_BYTES = 32 * 1024 * 1024
+CRAFTED = "Successfully crafted"
+# The environment's tools and their arguments, as a log record names them.
+ARGUMENTS = {"craft": ("ingredients", "target"), "get_info": ("items",), "view_inventory": (), "finish": ("message",)}
+READ_ONLY = frozenset({"get_info", "view_inventory"})  # tools that change nothing
+COMMANDS = {
+    "craft": "craft",
+    "info": "get_info",
+    "get_info": "get_info",
+    "inventory": "view_inventory",
+    "view_inventory": "view_inventory",
+    "finish": "finish",
+}
+_CLOEXEC = getattr(os, "O_CLOEXEC", 0)
+
+USAGE = """\
+usage: textcraft COMMAND [ARGUMENTS]
+
+Play the TextCraft task in $TEXTCRAFT_DIR (default /app/textcraft, the game's directory).
+
+  textcraft craft TARGET COUNT INGREDIENT=N [INGREDIENT=N ...]
+      Craft COUNT of TARGET from exactly these ingredients.  COUNT must be divisible by the recipe's
+      result_count; each ingredient's N is its recipe count times COUNT / result_count.
+      Example: textcraft craft m2_i2 2 m0_i1=2 m1_i1=1
+  textcraft info ITEM [ITEM ...]
+      Recipe information for the items, as a JSON list.
+  textcraft inventory
+      Your current inventory, as JSON {item_name: count}.
+  textcraft finish MESSAGE
+      Complete the task with a message saying what you achieved.  The task is graded on what your
+      inventory gained; no command is accepted after it.
+
+craft --json '{"ingredients": {...}, "target": [item, count]}' and info --json '[item, ...]' take the
+arguments as JSON.  get_info and view_inventory are other names for info and inventory.
+"""
+
+
+# ---------------------------------------------------------------------------------------------------- the world
+
+
+class Recipe:
+    __slots__ = ("result_count", "ingredients")
+
+    def __init__(self, result_count, ingredients):
+        self.result_count = result_count
+        self.ingredients = ingredients  # {item or "tag:<name>": count}, in the recipe's order
+
+
+class RecipeBook:
+    """A world's recipes (``recipes.json``), with the lookups of platoon's recipe databases.
+
+    The file lists each craftable item's recipes (ingredients as ``[name, count]`` pairs, in order), the base items,
+    every item's crafting depth (0 for items it does not list) and the items each ``tag:<name>`` ingredient accepts.
+    """
+
+    def __init__(self, data, sha256=None):
+        if not isinstance(data, dict) or data.get("format") != RECIPES_FORMAT:
+            raise ValueError("not a %s file" % RECIPES_FORMAT)
+        self.name = data["name"]
+        self.sha256 = sha256
+        self.recipes = {
+            item: [
+                Recipe(recipe["result_count"], {name: count for name, count in recipe["ingredients"]})
+                for recipe in recipes
+            ]
+            for item, recipes in data["recipes"].items()
+        }
+        self.base_items = frozenset(data["base_items"])
+        self.depths = dict(data["depths"])
+        self.tags = {tag: list(items) for tag, items in data["tags"].items()}
+
+    @classmethod
+    def load(cls, path):
+        with open(path, "rb") as handle:
+            raw = handle.read()
+        return cls(json.loads(raw.decode("utf-8")), sha256=hashlib.sha256(raw).hexdigest())
+
+    def get_recipes_for_item(self, item):
+        return self.recipes.get(item, [])
+
+    def can_craft(self, item):
+        return item in self.recipes
+
+    def is_base_item(self, item):
+        return item in self.base_items
+
+    def get_crafting_depth(self, item):
+        return self.depths.get(item, 0)
+
+    def get_items_for_tag(self, tag):
+        return list(self.tags.get(tag, []))
+
+
+def load_task(path):
+    """A task file (``task.json``): its goal, targets and starting inventory, and its recipes' SHA-256."""
+
+    with open(path, "rb") as handle:
+        task = json.loads(handle.read().decode("utf-8"))
+    if not isinstance(task, dict) or task.get("format") != TASK_FORMAT:
+        raise ValueError("%s is not a %s file" % (path, TASK_FORMAT))
+    for key in ("name", "goal", "target_items", "initial_inventory", "recipes_sha256"):
+        if key not in task:
+            raise ValueError("%s has no %r" % (path, key))
+    return task
+
+
+# ---------------------------------------------------------------------------------------------------- the game
+
+
+class Game:
+    """One episode: platoon's ``TextCraftEnvironment`` tools over an inventory, its rules and messages unchanged."""
+
+    def __init__(self, book, task):
+        self.book = book
+        self.goal = task["goal"]
+        self.target_items = dict(task["target_items"])
+        self.inventory = dict(task["initial_inventory"])
+        self.initial_inventory = dict(self.inventory)
+        self.finished = False
+        self.score = 0.0
+        self.reward_misc = {}
+        self.crafts = 0  # successful crafts
+
+    def call(self, tool, args):
+        """Run a tool with its arguments (the JSON values a tool call carries); the observation text it returns."""
+
+        if tool == "craft":
+            text = self.craft(args["ingredients"], args["target"])
+            self.crafts += text.startswith(CRAFTED)
+            return text
+        if tool == "get_info":
+            return json.dumps(self.get_info(args["items"]))
+        if tool == "view_inventory":
+            return json.dumps(dict(self.inventory))
+        if tool == "finish":
+            self.score, self.reward_misc = self.evaluate(args["message"])
+            self.finished = True
+            return args["message"]
+        raise ValueError("unknown tool %r" % (tool,))
+
+    def craft(self, ingredients, target):
+        """``TextCraftEnvironment._craft``: the same checks in the same order, with the same messages."""
+
+        if not isinstance(ingredients, dict):
+            return f"Error: ingredients must be a dict, got {type(ingredients).__name__}"
+        if not isinstance(target, (tuple, list)) or len(target) != 2:
+            return "Error: target must be a tuple of (item_name, count)"
+        target_item, target_count = target
+        if not isinstance(target_item, str):
+            return f"Error: target item must be a string, got {type(target_item).__name__}"
+        if not isinstance(target_count, int):
+            return f"Error: target count must be an int, got {type(target_count).__name__}"
+        if target_count <= 0:
+            return f"Error: target count must be positive, got {target_count}"
+        for ing_item, ing_count in ingredients.items():
+            if not isinstance(ing_item, str):
+                return f"Error: ingredient name must be a string, got {type(ing_item).__name__}"
+            if not isinstance(ing_count, int):
+                return f"Error: ingredient count for {ing_item} must be an int, got {type(ing_count).__name__}"
+            if ing_count <= 0:
+                return f"Error: ingredient count for {ing_item} must be positive, got {ing_count}"
+
+        book = self.book
+        recipes = book.get_recipes_for_item(target_item)
+        if not recipes:
+            return f"Error: No recipe found for {target_item}"
+
+        errors = []
+        for recipe_idx, recipe in enumerate(recipes):
+            if target_count % recipe.result_count != 0:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Target count {target_count} is not divisible "
+                    f"by recipe result count {recipe.result_count}"
+                )
+                continue
+            num_crafts = target_count // recipe.result_count
+
+            ingredient_mapping = {}  # recipe ingredient (or tag) -> provided item
+            recipe_error = None
+            for recipe_ing, recipe_count in recipe.ingredients.items():
+                total_required = recipe_count * num_crafts
+                if recipe_ing.startswith("tag:"):
+                    satisfying_items = book.get_items_for_tag(recipe_ing.replace("tag:", ""))
+                    provided = next(
+                        (
+                            item
+                            for item, count in ingredients.items()
+                            if item in satisfying_items and count == total_required
+                        ),
+                        None,
+                    )
+                    if provided is None:
+                        recipe_error = f"No ingredient provided for {recipe_ing}. Expected one of: {satisfying_items}"
+                        break
+                    ingredient_mapping[recipe_ing] = provided
+                else:
+                    if recipe_ing not in ingredients:
+                        recipe_error = f"Missing required ingredient {recipe_ing}"
+                        break
+                    if ingredients[recipe_ing] != total_required:
+                        recipe_error = (
+                            f"Wrong amount of {recipe_ing}. Need {total_required}, provided {ingredients[recipe_ing]}"
+                        )
+                        break
+                    ingredient_mapping[recipe_ing] = recipe_ing
+            if recipe_error:
+                errors.append(f"Recipe {recipe_idx + 1}: {recipe_error}")
+                continue
+
+            extra_ingredients = [item for item in ingredients if item not in ingredient_mapping.values()]
+            if extra_ingredients:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Extra ingredients not required: {', '.join(extra_ingredients)}"
+                )
+                continue
+
+            missing = []
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                required = recipe.ingredients[recipe_ing] * num_crafts
+                available = self.inventory.get(provided_ing, 0)
+                if available < required:
+                    missing.append(f"{provided_ing}: need {required}, have {available}")
+            if missing:
+                errors.append(f"Recipe {recipe_idx + 1}: Insufficient ingredients in inventory: {', '.join(missing)}")
+                continue
+
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                self.inventory[provided_ing] -= recipe.ingredients[recipe_ing] * num_crafts
+                if self.inventory[provided_ing] <= 0:
+                    del self.inventory[provided_ing]
+            crafted_count = recipe.result_count * num_crafts
+            self.inventory[target_item] = self.inventory.get(target_item, 0) + crafted_count
+            return f"Successfully crafted {crafted_count} {target_item}(s)"
+
+        return f"Error: All {len(recipes)} recipe(s) failed for {target_item}. Errors:\n" + "\n".join(errors)
+
+    def get_info(self, items):
+        """``TextCraftEnvironment._get_info``."""
+
+        book = self.book
+        results = []
+        for item in items:
+            info = {
+                "item": item,
+                "can_craft": book.can_craft(item),
+                "is_base": book.is_base_item(item),
+                "in_inventory": self.inventory.get(item, 0),
+                "crafting_depth": book.get_crafting_depth(item),
+                "recipes": [],
+            }
+            if info["can_craft"]:
+                for recipe in book.get_recipes_for_item(item):
+                    expanded = {}
+                    for ing, count in recipe.ingredients.items():
+                        if ing.startswith("tag:"):
+                            expanded[ing] = {"count": count, "use_one_of": book.get_items_for_tag(ing[4:])}
+                        else:
+                            expanded[ing] = count
+                    info["recipes"].append({"ingredients": expanded, "result_count": recipe.result_count})
+            results.append(info)
+        return results
+
+    def evaluate(self, finish_message):
+        """``TextCraftEnvironment.evaluate``: success when the inventory gained every target count and the finish
+        message is not empty."""
+
+        reward_misc = {}
+        score = 0.0
+        if finish_message:
+            if not self.target_items:
+                return 0.0, {"success": False, "error": "No target items defined in task", "reward/success": 0.0}
+            missing = {
+                item: required - (self.inventory.get(item, 0) - self.initial_inventory.get(item, 0))
+                for item, required in self.target_items.items()
+                if self.inventory.get(item, 0) - self.initial_inventory.get(item, 0) < required
+            }
+            reward_misc["success"] = not missing
+            if missing:
+                reward_misc["missing_items"] = missing
+            else:
+                score = 1.0
+            reward_misc["target_items"] = dict(self.target_items)
+            reward_misc["initial_inventory"] = dict(self.initial_inventory)
+            reward_misc["final_inventory"] = dict(self.inventory)
+        else:
+            reward_misc["success"] = False
+            reward_misc["error"] = "Episode ended without calling finish() - likely timeout or max steps reached"
+        reward_misc["reward/success"] = score
+        return score, reward_misc
+
+
+# ---------------------------------------------------------------------------------------------------- the log
+
+
+class LogError(ValueError):
+    """An action log the game could not have written: its replay stops there."""
+
+
+def _unique_pairs(pairs):
+    found = {}
+    for key, value in pairs:
+        if key in found:
+            raise ValueError("duplicate key %r" % (key,))
+        found[key] = value
+    return found
+
+
+def _no_constant(name):
+    raise ValueError("%s is not a JSON number" % name)
+
+
+def _finite_float(text):
+    value = float(text)
+    if value != value or value in (float("inf"), float("-inf")):
+        raise ValueError("%s is out of range" % text)
+    return value
+
+
+def parse_json(text):
+    """Strict JSON: no duplicate keys, no NaN or Infinity (also none that overflows, such as 1e999), so every value
+    it returns can be written back to the log."""
+
+    return json.loads(text, object_pairs_hook=_unique_pairs, parse_constant=_no_constant, parse_float=_finite_float)
+
+
+def encode_record(seq, tool, args, ok=None):
+    """A log line: ``{"seq", "tool", "args"}``, plus ``"ok"`` (the craft succeeded) for a craft."""
+
+    record = {"seq": seq, "tool": tool, "args": args}
+    if tool == "craft":
+        record["ok"] = bool(ok)
+    return (json.dumps(record, ensure_ascii=True, separators=(",", ":"), allow_nan=False) + "\n").encode("ascii")
+
+
+def check_arguments(tool, args):
+    """``args`` as a log record or a command may give them to ``tool``; ValueError says what is wrong."""
+
+    if not isinstance(args, dict) or sorted(args) != sorted(ARGUMENTS[tool]):
+        raise ValueError("%s takes the arguments %s" % (tool, ", ".join(ARGUMENTS[tool]) or "none"))
+    if tool == "get_info" and (
+        not isinstance(args["items"], list) or not all(isinstance(item, str) for item in args["items"])
+    ):
+        raise ValueError("get_info takes a list of item names")
+    if tool == "finish" and not isinstance(args["message"], str):
+        raise ValueError("finish takes a message string")
+
+
+def _record(line, seq):
+    try:
+        record = parse_json(line.decode("utf-8"))
+    except (UnicodeDecodeError, ValueError, RecursionError) as exc:
+        raise LogError("record %d is not a JSON object: %s" % (seq, exc)) from None
+    if not isinstance(record, dict):
+        raise LogError("record %d is not a JSON object" % seq)
+    tool = record.get("tool")
+    if not isinstance(tool, str) or tool not in ARGUMENTS:
+        raise LogError("record %d names no tool of the game: %r" % (seq, tool))
+    keys = {"seq", "tool", "args", "ok"} if tool == "craft" else {"seq", "tool", "args"}
+    if set(record) != keys:
+        raise LogError("record %d must have exactly the keys %s" % (seq, sorted(keys)))
+    if type(record["seq"]) is not int or record["seq"] != seq:
+        raise LogError("record %d is numbered %r" % (seq, record["seq"]))
+    try:
+        check_arguments(tool, record["args"])
+    except ValueError as exc:
+        raise LogError("record %d: %s" % (seq, exc)) from None
+    if tool == "craft" and not isinstance(record["ok"], bool):
+        raise LogError("record %d: ok must be true or false" % seq)
+    return tool, record["args"], record.get("ok")
+
+
+def replay(game, data):
+    """Apply a log's records to ``game``; how many there were.  LogError at the first record the game could not
+    have written: the replay stops there.
+
+    The records are read one at a time, and those of ``get_info`` and ``view_inventory``, which change nothing, have
+    their arguments checked but their output never rebuilt, so replaying any log within the size cap takes seconds
+    and a bounded amount of memory (a ``get_info`` record can name millions of items)."""
+
+    if not data:
+        return 0
+    if not data.endswith(b"\n"):
+        raise LogError("the last record does not end with a newline")
+    seq = start = 0
+    while start < len(data):
+        end = data.index(b"\n", start)
+        seq += 1
+        if game.finished:
+            raise LogError("record %d follows finish" % seq)
+        tool, args, ok = _record(data[start:end], seq)
+        start = end + 1
+        if tool in READ_ONLY:
+            continue
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:  # arguments no command writes
+            raise LogError("record %d cannot be applied: %s: %s" % (seq, type(exc).__name__, exc)) from None
+        if tool == "craft" and text.startswith(CRAFTED) != ok:
+            claim = "succeeded" if ok else "failed"
+            raise LogError("record %d says the craft %s, but the rules give: %s" % (seq, claim, text))
+    return seq
+
+
+# ---------------------------------------------------------------------------------------------------- the command
+
+
+class UsageError(ValueError):
+    pass
+
+
+class Result:
+    """What a command printed and its exit status: 0 done, 1 a game error (a rejected craft, the episode is over),
+    2 a usage error (nothing was run or logged), 3 the task cannot be played."""
+
+    def __init__(self, code, out="", err=""):
+        self.code = code
+        self.out = out
+        self.err = err
+
+
+def parse_command(argv):
+    """``(tool, args)`` of a command line; UsageError when it is not one."""
+
+    if not argv:
+        raise UsageError("no command")
+    tool = COMMANDS.get(argv[0])
+    if tool is None:
+        raise UsageError("unknown command %r" % argv[0])
+    rest = argv[1:]
+    if tool == "craft":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("craft --json takes one JSON object")
+            args = _json_argument(rest[1])
+            if not isinstance(args, dict) or sorted(args) != ["ingredients", "target"]:
+                raise UsageError('craft --json takes {"ingredients": {...}, "target": [item, count]}')
+            return tool, args
+        if len(rest) < 2:
+            raise UsageError("craft takes TARGET COUNT INGREDIENT=N ...")
+        ingredients = {}
+        for word in rest[2:]:
+            name, sep, count = word.rpartition("=")
+            if not sep or not name:
+                raise UsageError("ingredients are INGREDIENT=N, got %r" % word)
+            if name in ingredients:
+                raise UsageError("ingredient %r is given twice" % name)
+            ingredients[name] = _integer(count, "the count of %s" % name)
+        return tool, {"ingredients": ingredients, "target": [rest[0], _integer(rest[1], "COUNT")]}
+    if tool == "get_info":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("info --json takes one JSON list")
+            items = _json_argument(rest[1])
+        else:
+            items = list(rest)
+        args = {"items": items}
+    elif tool == "view_inventory":
+        if rest:
+            raise UsageError("inventory takes no arguments")
+        args = {}
+    else:
+        if not rest:
+            raise UsageError("finish takes a MESSAGE saying what you achieved")
+        args = {"message": " ".join(rest)}
+    try:
+        check_arguments(tool, args)
+    except ValueError as exc:
+        raise UsageError(str(exc)) from None
+    return tool, args
+
+
+def _json_argument(text):
+    try:
+        return parse_json(text)
+    except (ValueError, RecursionError) as exc:
+        raise UsageError("not valid JSON: %s" % exc) from None
+
+
+def _integer(text, what):
+    try:
+        return int(text)
+    except ValueError:
+        raise UsageError("%s must be an integer, got %r" % (what, text)) from None
+
+
+def default_directory():
+    return os.environ.get("TEXTCRAFT_DIR") or os.path.dirname(os.path.abspath(__file__))
+
+
+def run(argv, directory=None, recipes=None):
+    """Run a command line against the task in ``directory`` (default ``$TEXTCRAFT_DIR``, else this file's
+    directory), with the recipes ``recipes`` (default ``$TEXTCRAFT_RECIPES``, else the directory's
+    ``recipes.json``)."""
+
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        return Result(0 if argv else 2, USAGE)
+    if argv[0] == "--version":
+        return Result(0, "textcraft %s" % VERSION)
+    try:
+        tool, args = parse_command(argv)
+    except UsageError as exc:
+        return Result(2, err="textcraft: %s\n\n%s" % (exc, USAGE))
+    directory = directory or default_directory()
+    try:
+        task = load_task(os.path.join(directory, TASK_FILE))
+        book = RecipeBook.load(recipes or os.environ.get("TEXTCRAFT_RECIPES") or os.path.join(directory, RECIPES_FILE))
+    except (OSError, ValueError, KeyError) as exc:
+        return Result(3, err="textcraft: cannot load the task: %s" % exc)
+    if task["recipes_sha256"] != book.sha256:
+        return Result(3, err="textcraft: the recipes (%s) are not the ones of this task" % book.sha256)
+    path = os.path.join(directory, LOG_FILE)
+    try:
+        fd = os.open(path, os.O_RDWR | os.O_CREAT | os.O_APPEND | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    except OSError as exc:
+        why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+        return Result(3, err="textcraft: cannot open the action log %s: %s" % (path, why))
+    try:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_EX)
+        except OSError:
+            pass  # a file system without locks: commands are not expected to overlap
+        if not stat.S_ISREG(os.fstat(fd).st_mode):
+            return Result(3, err="textcraft: the action log %s is not a regular file" % path)
+        data = _read_all(fd)
+        game = Game(book, task)
+        try:
+            seq = replay(game, data) + 1
+        except LogError as exc:
+            return Result(
+                3, err="textcraft: the action log %s does not replay (%s); the episode cannot continue" % (path, exc)
+            )
+        if game.finished:
+            return Result(
+                1, "Error: the episode is finished (textcraft finish was called); no command is accepted after it"
+            )
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:
+            return Result(2, err="textcraft: cannot run %s: %s: %s" % (tool, type(exc).__name__, exc))
+        ok = text.startswith(CRAFTED)
+        line = encode_record(seq, tool, args, ok)
+        if len(data) + len(line) > LOG_CAP_BYTES:
+            return Result(1, "Error: the action log is full (%d bytes); no command is accepted" % LOG_CAP_BYTES)
+        _write_all(fd, line)
+    finally:
+        os.close(fd)
+    return Result(1 if tool == "craft" and not ok else 0, text)
+
+
+def _read_all(fd):
+    os.lseek(fd, 0, os.SEEK_SET)
+    chunks = []
+    while True:
+        chunk = os.read(fd, 1 << 20)
+        if not chunk:
+            return b"".join(chunks)
+        chunks.append(chunk)
+
+
+def _write_all(fd, data):
+    view = memoryview(data)
+    while view:
+        view = view[os.write(fd, view) :]
+
+
+# ---------------------------------------------------------------------------------------------------- the verifier
+
+
+def read_untrusted(root, relative, cap=LOG_CAP_BYTES):
+    """The bytes of ``root/relative``, reached without following a symbolic link below ``root``; None when it does
+    not exist.  LogError when it is not a regular file, or holds more than ``cap`` bytes."""
+
+    parts = [part for part in relative.split("/") if part not in ("", ".")]
+    if not parts or ".." in parts:
+        raise ValueError("%r is not a path below the root" % relative)
+    directory = os.open(root, os.O_RDONLY | os.O_DIRECTORY | _CLOEXEC)
+    try:
+        for part in parts[:-1]:
+            try:
+                below = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW | _CLOEXEC, dir_fd=directory)
+            except FileNotFoundError:
+                return None
+            except OSError as exc:
+                raise LogError("%s on the way to the action log is not a directory (%s)" % (part, exc.strerror))
+            os.close(directory)
+            directory = below
+        try:
+            fd = os.open(parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK | _CLOEXEC, dir_fd=directory)
+        except FileNotFoundError:
+            return None
+        except OSError as exc:
+            why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+            raise LogError("cannot open the action log: %s" % why)
+    finally:
+        os.close(directory)
+    try:
+        info = os.fstat(fd)
+        if not stat.S_ISREG(info.st_mode):
+            raise LogError("the action log is not a regular file")
+        if info.st_size > cap:
+            raise LogError("the action log holds %d bytes; the limit is %d" % (info.st_size, cap))
+        chunks, total = [], 0
+        while total <= cap:
+            chunk = os.read(fd, min(1 << 20, cap + 1 - total))
+            if not chunk:
+                break
+            chunks.append(chunk)
+            total += len(chunk)
+        if total > cap:
+            raise LogError("the action log holds more than %d bytes" % cap)
+        return b"".join(chunks)
+    finally:
+        os.close(fd)
+
+
+def verify(task_path, recipes_path, root, log, out=None):
+    """Grade the log at ``root/log`` against the trusted task and recipes; the verdict (``reward`` and why).
+    Writes ``reward.json`` and ``textcraft-verdict.json`` into ``out`` when given."""
+
+    task = load_task(task_path)
+    book = RecipeBook.load(recipes_path)
+    if task["recipes_sha256"] != book.sha256:
+        raise ValueError("the verifier's recipes %s are not the task's %s" % (book.sha256, task["recipes_sha256"]))
+    game = Game(book, task)
+    verdict = {"reward": 0.0, "task": task["name"], "version": VERSION, "records": 0, "crafts": 0, "finished": False}
+    try:
+        data = read_untrusted(root, log)
+        if data is None:
+            verdict["reason"] = "no action log: no textcraft command ran"
+        else:
+            verdict["log_bytes"] = len(data)
+            verdict["records"] = replay(game, data)
+            verdict["crafts"] = game.crafts
+            verdict["finished"] = game.finished
+            if not game.finished:
+                verdict["reason"] = "the episode did not end with textcraft finish"
+            elif game.score >= 1.0:
+                verdict["reward"] = 1.0
+                verdict["reason"] = "finished with every target crafted"
+            elif game.reward_misc.get("missing_items"):
+                verdict["reason"] = "finished without every target crafted"
+                verdict["missing_items"] = game.reward_misc["missing_items"]
+            else:
+                verdict["reason"] = "finished with an empty message"
+    except LogError as exc:
+        verdict["reason"] = "the action log is not one the game wrote: %s" % exc
+    if out is not None:
+        _write_new(out, VERDICT_FILE, json.dumps(verdict, indent=1, sort_keys=True) + "\n")
+        _write_new(out, REWARD_FILE, json.dumps({"reward": verdict["reward"]}) + "\n")
+    return verdict
+
+
+def _write_new(directory, name, text):
+    """Write ``directory/name`` through a new file and a rename, so the name ends up a regular file whatever was
+    there."""
+
+    temporary = os.path.join(directory, ".%s.%d.tmp" % (name, os.getpid()))
+    fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    try:
+        _write_all(fd, text.encode("utf-8"))
+        os.fsync(fd)
+    finally:
+        os.close(fd)
+    os.replace(temporary, os.path.join(directory, name))
+
+
+def verify_main(argv):
+    parser = argparse.ArgumentParser(prog="textcraft_game.py verify", description="Grade a TextCraft action log.")
+    parser.add_argument("--task", required=True, help="the trusted task.json")
+    parser.add_argument("--recipes", required=True, help="the trusted recipes.json")
+    parser.add_argument("--root", required=True, help="the sandbox root the log path is below")
+    parser.add_argument("--log", required=True, help="the log's path below the root")
+    parser.add_argument("--out", required=True, help="the verifier's output directory (reward.json)")
+    options = parser.parse_args(argv)
+    try:
+        verdict = verify(options.task, options.recipes, options.root, options.log, options.out)
+    except (OSError, ValueError, KeyError) as exc:
+        print("textcraft verify: cannot grade: %s" % exc, file=sys.stderr)
+        return 1
+    print(
+        "reward %g: %s (%d records, %d crafts)"
+        % (verdict["reward"], verdict["reason"], verdict["records"], verdict["crafts"])
+    )
+    return 0
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv[:1] == ["verify"]:
+        return verify_main(argv[1:])
+    result = run(argv)
+    if result.out:
+        print(result.out)
+    if result.err:
+        print(result.err, file=sys.stderr)
+    return result.code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/textcraft-synth-train-easy-00617/instruction.md

@@ -0,0 +1,38 @@
+You are an agent in a crafting game. Your goal is to craft items by combining ingredients.
+You have access to an inventory of existing ingredients, which are sufficient to craft the target items; though, you may need to craft intermediate ingredients first.
+
+Note: If you already have one of the target items in your inventory, you should craft the requested number of the target on top of what you already have.
+For example, if you already have 2 wooden_pickaxes but your goal is to craft 3, your inventory should end up with 5 wooden_pickaxes.
+
+## Task
+
+Craft the following items: 1x c0_i2_20
+
+## Actions
+
+You act through the `textcraft` command in the shell:
+
+1. `textcraft craft TARGET TOTAL_COUNT INGREDIENT=COUNT [INGREDIENT=COUNT ...]`
+   Craft items using ingredients from your inventory.
+   - INGREDIENT=COUNT pairs: the items to consume and how many of each
+   - TARGET TOTAL_COUNT: the item to craft and its total count, which must be divisible by the recipe's result_count
+   - Example: `textcraft craft m2_i2 2 m0_i1=2 m1_i1=1`
+
+2. `textcraft info ITEM [ITEM ...]`
+   Get recipe information for items.
+   - Prints a JSON list with {"item": str, "can_craft": bool, "is_base": bool, "in_inventory": int, "crafting_depth": int, "recipes": [...]}
+   - crafting_depth indicates complexity: 0=base item, 1=direct craft, 2+=needs intermediate steps
+   - Each recipe shows {"ingredients": {...}, "result_count": int}
+   - Example: `textcraft info m2_i2 raw_m0`
+
+3. `textcraft inventory`
+   View your current inventory.
+   - Prints JSON {item_name: count}
+
+4. `textcraft finish MESSAGE`
+   Complete the task.
+   - Example: `textcraft finish "Successfully crafted all required items"`
+   - The task is graded when you finish, on what your inventory gained; no command is accepted after it, and a
+     task that never finishes counts as failed.
+
+The game keeps its state in `/app/textcraft`; change it only through the `textcraft` command.

tasks/textcraft-synth-train-easy-00617/solution/solve.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# The reference solution of textcraft-synth-train-easy-00617: the source task's gold trajectory (1 crafts), then finish.
+set -euo pipefail
+if ! command -v textcraft >/dev/null 2>&1; then
+  # platoon's process provider runs no image, so there is no textcraft command: run the game file itself.
+  textcraft() { python3 -I "${PLATOON_SANDBOX_ROOT:-}/app/textcraft/textcraft_game.py" "$@"; }
+fi
+textcraft craft c0_i2_20 2 c4_ore=1 c3_ore=1
+textcraft finish 'Crafted 1x c0_i2_20'

tasks/textcraft-synth-train-easy-00617/task.toml

@@ -0,0 +1,33 @@
+schema_version = "1.4"
+# The game's action log: a separate verifier receives it at the same path.
+artifacts = ["/app/textcraft/actions.jsonl"]
+
+[task]
+name = "textcraft-synth/train-easy-00617"
+description = "TextCraft-Synth: craft the following items: 1x c0_i2_20 (easy, crafting depth 2)"
+keywords = ["textcraft", "textcraft-synth", "crafting", "planning"]
+
+[metadata]
+environment = "textcraft-synth@1"
+split = "train"
+difficulty = "easy"
+max_depth = 2
+num_craft_steps = 1
+goal = "Craft the following items: 1x c0_i2_20"
+source_task_id = "textcraft_synth.train.617"
+env_task_id = "train:617"
+env_split_task_id = "train-easy:131"
+
+[verifier]
+environment_mode = "separate"
+timeout_sec = 180.0
+
+[agent]
+timeout_sec = 660.0
+
+[environment]
+network_mode = "no-network"
+cpus = 1
+memory_mb = 2048
+gpus = 0
+build_timeout_sec = 900.0

tasks/textcraft-synth-train-easy-00617/tests/Dockerfile

@@ -0,0 +1,13 @@
+# textcraft-synth-train-easy-00617: task.json sha256:fbfd9cadd4cb0347a5fb736799e60675d0ca012110741de9f6f6fecbc5e46faa
+FROM docker.io/library/python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1
+# The same image as the task's environment, so one image serves the agent and the verifier.
+RUN set -eux; \
+    printf '#!/bin/sh\nexec python3 -I /app/textcraft/textcraft_game.py "$@"\n' \
+        > /usr/local/bin/textcraft; \
+    chmod 0755 /usr/local/bin/textcraft; \
+    apt-get -o APT::Sandbox::User=root update; \
+    apt-get -o APT::Sandbox::User=root install -y --no-install-recommends tmux; \
+    rm -rf /var/lib/apt/lists/*
+# The verifier's trusted copies of the grader, the game, the recipes and the task.
+WORKDIR /app
+COPY test.sh textcraft_game.py recipes.json task.json /tests/

tasks/textcraft-synth-train-easy-00617/tests/task.json

@@ -0,0 +1,15 @@
+{
+ "format": "textcraft-task/1",
+ "name": "textcraft-synth-train-easy-00617",
+ "world": "textcraft-synth",
+ "goal": "Craft the following items: 1x c0_i2_20",
+ "target_items": {
+  "c0_i2_20": 1
+ },
+ "initial_inventory": {
+  "c4_ore": 2,
+  "c3_ore": 2,
+  "c7_ore": 5
+ },
+ "recipes_sha256": "a020eec273337c66b35c0fc487664e35c44da65ad18e9afffe6a4c25af949f10"
+}

tasks/textcraft-synth-train-easy-00617/tests/test.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# Grade a TextCraft episode: replay the agent's action log (/app/textcraft/actions.jsonl) from the task's starting
+# inventory with the game's rules, using this directory's own copies of the game, the recipes and the task.  The
+# reward is 1 only when the log is an episode the rules allow that ends in `textcraft finish` with every target
+# crafted (the verdict goes to textcraft-verdict.json).  It runs in the agent's container (a shared verifier) or in a
+# separate verifier that received the log as an artifact.
+# PLATOON_SANDBOX_ROOT: platoon's process provider runs this on the host, with the sandbox's files below that
+# directory; sandboxes leave it unset.
+set -u
+root="${PLATOON_SANDBOX_ROOT:-}"
+tests="$root/tests"
+out="$root/logs/verifier"
+mkdir -p "$out"
+# A fresh verdict: nothing the agent may have left in the verifier's directory counts.
+rm -rf -- "$out/reward.json" "$out/reward.txt" "$out/textcraft-verdict.json"
+exec python3 -I "$tests/textcraft_game.py" verify --task "$tests/task.json" --recipes "$tests/recipes.json" \
+  --root "$root/" --log app/textcraft/actions.jsonl --out "$out"

tasks/textcraft-synth-train-easy-00617/tests/textcraft_game.py

@@ -0,0 +1,756 @@
+"""TextCraft in a container: the ``textcraft`` command of a Harbor task, and the verifier that grades it.
+
+This one file is the whole game.  It needs Python 3.8 or later and its standard library only, and it never imports
+platoon: the exporter (``python -m platoon.textcraft.harbor export``) copies it into every task as
+``textcraft_game.py``, into ``environment/`` (the container gets it at ``/app/textcraft/textcraft_game.py``, which
+the image's ``textcraft`` command runs) and into ``tests/`` for the verifier.  It reproduces platoon's TextCraft
+environments (``platoon.textcraft.env``): the same four tools with the same arguments, the same observation text
+and the same success rule.
+
+=========================================  ===================  ===============================================
+command                                    environment tool     prints
+=========================================  ===================  ===============================================
+``textcraft craft TARGET COUNT ING=N ...``  ``craft``            ``Successfully crafted ...`` or ``Error: ...``
+``textcraft info ITEM ...``                 ``get_info``         the recipe information, as JSON
+``textcraft inventory``                     ``view_inventory``   the inventory, as JSON
+``textcraft finish MESSAGE``                ``finish``           the message; the episode ends
+=========================================  ===================  ===============================================
+
+``craft --json '{"ingredients": {...}, "target": [item, count]}'`` and ``info --json '[item, ...]'`` take a tool's
+arguments as JSON values, the way a tool call passes them.
+
+**State.**  ``$TEXTCRAFT_DIR`` (default: this file's directory, ``/app/textcraft`` in a task's container) holds the
+task (``task.json``: goal, targets, starting inventory), the world's recipes (``recipes.json``, or
+``$TEXTCRAFT_RECIPES``) and the action log (``actions.jsonl``).  The log is the state: under an exclusive lock,
+every command replays the log from the starting inventory, runs, and appends its own record (``{"seq", "tool",
+"args"}``, plus ``"ok"`` for a craft).  Nothing is accepted after ``finish``, or once the log no longer replays.
+
+**Grading** (``python3 textcraft_game.py verify``, from the task's ``tests/test.sh``) replays the log with trusted
+copies of the task and the recipes.  The reward is 1 when the log is an episode the rules allow that ends in
+``finish`` with a message, and the inventory then holds every target count on top of the starting inventory (the
+environment's rule); otherwise it is 0.  The log must be a regular file of at most 32 MiB, reached without a
+symbolic link below the sandbox root.  A record that does not parse, breaks the record format or the numbering,
+follows ``finish``, or claims a craft outcome the rules do not give ends the replay with reward 0: only a log the
+command could have written earns a reward.  A craft the rules reject, recorded as rejected, changes nothing, as in
+the environment.
+"""
+
+from __future__ import annotations
+
+import argparse
+import errno
+import fcntl
+import hashlib
+import json
+import os
+import stat
+import sys
+
+VERSION = "1.0"
+TASK_FORMAT = "textcraft-task/1"
+RECIPES_FORMAT = "textcraft-recipes/1"
+TASK_FILE = "task.json"
+LOG_FILE = "actions.jsonl"
+RECIPES_FILE = "recipes.json"
+REWARD_FILE = "reward.json"
+VERDICT_FILE = "textcraft-verdict.json"
+LOG_CAP_BYTES = 32 * 1024 * 1024
+CRAFTED = "Successfully crafted"
+# The environment's tools and their arguments, as a log record names them.
+ARGUMENTS = {"craft": ("ingredients", "target"), "get_info": ("items",), "view_inventory": (), "finish": ("message",)}
+READ_ONLY = frozenset({"get_info", "view_inventory"})  # tools that change nothing
+COMMANDS = {
+    "craft": "craft",
+    "info": "get_info",
+    "get_info": "get_info",
+    "inventory": "view_inventory",
+    "view_inventory": "view_inventory",
+    "finish": "finish",
+}
+_CLOEXEC = getattr(os, "O_CLOEXEC", 0)
+
+USAGE = """\
+usage: textcraft COMMAND [ARGUMENTS]
+
+Play the TextCraft task in $TEXTCRAFT_DIR (default /app/textcraft, the game's directory).
+
+  textcraft craft TARGET COUNT INGREDIENT=N [INGREDIENT=N ...]
+      Craft COUNT of TARGET from exactly these ingredients.  COUNT must be divisible by the recipe's
+      result_count; each ingredient's N is its recipe count times COUNT / result_count.
+      Example: textcraft craft m2_i2 2 m0_i1=2 m1_i1=1
+  textcraft info ITEM [ITEM ...]
+      Recipe information for the items, as a JSON list.
+  textcraft inventory
+      Your current inventory, as JSON {item_name: count}.
+  textcraft finish MESSAGE
+      Complete the task with a message saying what you achieved.  The task is graded on what your
+      inventory gained; no command is accepted after it.
+
+craft --json '{"ingredients": {...}, "target": [item, count]}' and info --json '[item, ...]' take the
+arguments as JSON.  get_info and view_inventory are other names for info and inventory.
+"""
+
+
+# ---------------------------------------------------------------------------------------------------- the world
+
+
+class Recipe:
+    __slots__ = ("result_count", "ingredients")
+
+    def __init__(self, result_count, ingredients):
+        self.result_count = result_count
+        self.ingredients = ingredients  # {item or "tag:<name>": count}, in the recipe's order
+
+
+class RecipeBook:
+    """A world's recipes (``recipes.json``), with the lookups of platoon's recipe databases.
+
+    The file lists each craftable item's recipes (ingredients as ``[name, count]`` pairs, in order), the base items,
+    every item's crafting depth (0 for items it does not list) and the items each ``tag:<name>`` ingredient accepts.
+    """
+
+    def __init__(self, data, sha256=None):
+        if not isinstance(data, dict) or data.get("format") != RECIPES_FORMAT:
+            raise ValueError("not a %s file" % RECIPES_FORMAT)
+        self.name = data["name"]
+        self.sha256 = sha256
+        self.recipes = {
+            item: [
+                Recipe(recipe["result_count"], {name: count for name, count in recipe["ingredients"]})
+                for recipe in recipes
+            ]
+            for item, recipes in data["recipes"].items()
+        }
+        self.base_items = frozenset(data["base_items"])
+        self.depths = dict(data["depths"])
+        self.tags = {tag: list(items) for tag, items in data["tags"].items()}
+
+    @classmethod
+    def load(cls, path):
+        with open(path, "rb") as handle:
+            raw = handle.read()
+        return cls(json.loads(raw.decode("utf-8")), sha256=hashlib.sha256(raw).hexdigest())
+
+    def get_recipes_for_item(self, item):
+        return self.recipes.get(item, [])
+
+    def can_craft(self, item):
+        return item in self.recipes
+
+    def is_base_item(self, item):
+        return item in self.base_items
+
+    def get_crafting_depth(self, item):
+        return self.depths.get(item, 0)
+
+    def get_items_for_tag(self, tag):
+        return list(self.tags.get(tag, []))
+
+
+def load_task(path):
+    """A task file (``task.json``): its goal, targets and starting inventory, and its recipes' SHA-256."""
+
+    with open(path, "rb") as handle:
+        task = json.loads(handle.read().decode("utf-8"))
+    if not isinstance(task, dict) or task.get("format") != TASK_FORMAT:
+        raise ValueError("%s is not a %s file" % (path, TASK_FORMAT))
+    for key in ("name", "goal", "target_items", "initial_inventory", "recipes_sha256"):
+        if key not in task:
+            raise ValueError("%s has no %r" % (path, key))
+    return task
+
+
+# ---------------------------------------------------------------------------------------------------- the game
+
+
+class Game:
+    """One episode: platoon's ``TextCraftEnvironment`` tools over an inventory, its rules and messages unchanged."""
+
+    def __init__(self, book, task):
+        self.book = book
+        self.goal = task["goal"]
+        self.target_items = dict(task["target_items"])
+        self.inventory = dict(task["initial_inventory"])
+        self.initial_inventory = dict(self.inventory)
+        self.finished = False
+        self.score = 0.0
+        self.reward_misc = {}
+        self.crafts = 0  # successful crafts
+
+    def call(self, tool, args):
+        """Run a tool with its arguments (the JSON values a tool call carries); the observation text it returns."""
+
+        if tool == "craft":
+            text = self.craft(args["ingredients"], args["target"])
+            self.crafts += text.startswith(CRAFTED)
+            return text
+        if tool == "get_info":
+            return json.dumps(self.get_info(args["items"]))
+        if tool == "view_inventory":
+            return json.dumps(dict(self.inventory))
+        if tool == "finish":
+            self.score, self.reward_misc = self.evaluate(args["message"])
+            self.finished = True
+            return args["message"]
+        raise ValueError("unknown tool %r" % (tool,))
+
+    def craft(self, ingredients, target):
+        """``TextCraftEnvironment._craft``: the same checks in the same order, with the same messages."""
+
+        if not isinstance(ingredients, dict):
+            return f"Error: ingredients must be a dict, got {type(ingredients).__name__}"
+        if not isinstance(target, (tuple, list)) or len(target) != 2:
+            return "Error: target must be a tuple of (item_name, count)"
+        target_item, target_count = target
+        if not isinstance(target_item, str):
+            return f"Error: target item must be a string, got {type(target_item).__name__}"
+        if not isinstance(target_count, int):
+            return f"Error: target count must be an int, got {type(target_count).__name__}"
+        if target_count <= 0:
+            return f"Error: target count must be positive, got {target_count}"
+        for ing_item, ing_count in ingredients.items():
+            if not isinstance(ing_item, str):
+                return f"Error: ingredient name must be a string, got {type(ing_item).__name__}"
+            if not isinstance(ing_count, int):
+                return f"Error: ingredient count for {ing_item} must be an int, got {type(ing_count).__name__}"
+            if ing_count <= 0:
+                return f"Error: ingredient count for {ing_item} must be positive, got {ing_count}"
+
+        book = self.book
+        recipes = book.get_recipes_for_item(target_item)
+        if not recipes:
+            return f"Error: No recipe found for {target_item}"
+
+        errors = []
+        for recipe_idx, recipe in enumerate(recipes):
+            if target_count % recipe.result_count != 0:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Target count {target_count} is not divisible "
+                    f"by recipe result count {recipe.result_count}"
+                )
+                continue
+            num_crafts = target_count // recipe.result_count
+
+            ingredient_mapping = {}  # recipe ingredient (or tag) -> provided item
+            recipe_error = None
+            for recipe_ing, recipe_count in recipe.ingredients.items():
+                total_required = recipe_count * num_crafts
+                if recipe_ing.startswith("tag:"):
+                    satisfying_items = book.get_items_for_tag(recipe_ing.replace("tag:", ""))
+                    provided = next(
+                        (
+                            item
+                            for item, count in ingredients.items()
+                            if item in satisfying_items and count == total_required
+                        ),
+                        None,
+                    )
+                    if provided is None:
+                        recipe_error = f"No ingredient provided for {recipe_ing}. Expected one of: {satisfying_items}"
+                        break
+                    ingredient_mapping[recipe_ing] = provided
+                else:
+                    if recipe_ing not in ingredients:
+                        recipe_error = f"Missing required ingredient {recipe_ing}"
+                        break
+                    if ingredients[recipe_ing] != total_required:
+                        recipe_error = (
+                            f"Wrong amount of {recipe_ing}. Need {total_required}, provided {ingredients[recipe_ing]}"
+                        )
+                        break
+                    ingredient_mapping[recipe_ing] = recipe_ing
+            if recipe_error:
+                errors.append(f"Recipe {recipe_idx + 1}: {recipe_error}")
+                continue
+
+            extra_ingredients = [item for item in ingredients if item not in ingredient_mapping.values()]
+            if extra_ingredients:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Extra ingredients not required: {', '.join(extra_ingredients)}"
+                )
+                continue
+
+            missing = []
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                required = recipe.ingredients[recipe_ing] * num_crafts
+                available = self.inventory.get(provided_ing, 0)
+                if available < required:
+                    missing.append(f"{provided_ing}: need {required}, have {available}")
+            if missing:
+                errors.append(f"Recipe {recipe_idx + 1}: Insufficient ingredients in inventory: {', '.join(missing)}")
+                continue
+
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                self.inventory[provided_ing] -= recipe.ingredients[recipe_ing] * num_crafts
+                if self.inventory[provided_ing] <= 0:
+                    del self.inventory[provided_ing]
+            crafted_count = recipe.result_count * num_crafts
+            self.inventory[target_item] = self.inventory.get(target_item, 0) + crafted_count
+            return f"Successfully crafted {crafted_count} {target_item}(s)"
+
+        return f"Error: All {len(recipes)} recipe(s) failed for {target_item}. Errors:\n" + "\n".join(errors)
+
+    def get_info(self, items):
+        """``TextCraftEnvironment._get_info``."""
+
+        book = self.book
+        results = []
+        for item in items:
+            info = {
+                "item": item,
+                "can_craft": book.can_craft(item),
+                "is_base": book.is_base_item(item),
+                "in_inventory": self.inventory.get(item, 0),
+                "crafting_depth": book.get_crafting_depth(item),
+                "recipes": [],
+            }
+            if info["can_craft"]:
+                for recipe in book.get_recipes_for_item(item):
+                    expanded = {}
+                    for ing, count in recipe.ingredients.items():
+                        if ing.startswith("tag:"):
+                            expanded[ing] = {"count": count, "use_one_of": book.get_items_for_tag(ing[4:])}
+                        else:
+                            expanded[ing] = count
+                    info["recipes"].append({"ingredients": expanded, "result_count": recipe.result_count})
+            results.append(info)
+        return results
+
+    def evaluate(self, finish_message):
+        """``TextCraftEnvironment.evaluate``: success when the inventory gained every target count and the finish
+        message is not empty."""
+
+        reward_misc = {}
+        score = 0.0
+        if finish_message:
+            if not self.target_items:
+                return 0.0, {"success": False, "error": "No target items defined in task", "reward/success": 0.0}
+            missing = {
+                item: required - (self.inventory.get(item, 0) - self.initial_inventory.get(item, 0))
+                for item, required in self.target_items.items()
+                if self.inventory.get(item, 0) - self.initial_inventory.get(item, 0) < required
+            }
+            reward_misc["success"] = not missing
+            if missing:
+                reward_misc["missing_items"] = missing
+            else:
+                score = 1.0
+            reward_misc["target_items"] = dict(self.target_items)
+            reward_misc["initial_inventory"] = dict(self.initial_inventory)
+            reward_misc["final_inventory"] = dict(self.inventory)
+        else:
+            reward_misc["success"] = False
+            reward_misc["error"] = "Episode ended without calling finish() - likely timeout or max steps reached"
+        reward_misc["reward/success"] = score
+        return score, reward_misc
+
+
+# ---------------------------------------------------------------------------------------------------- the log
+
+
+class LogError(ValueError):
+    """An action log the game could not have written: its replay stops there."""
+
+
+def _unique_pairs(pairs):
+    found = {}
+    for key, value in pairs:
+        if key in found:
+            raise ValueError("duplicate key %r" % (key,))
+        found[key] = value
+    return found
+
+
+def _no_constant(name):
+    raise ValueError("%s is not a JSON number" % name)
+
+
+def _finite_float(text):
+    value = float(text)
+    if value != value or value in (float("inf"), float("-inf")):
+        raise ValueError("%s is out of range" % text)
+    return value
+
+
+def parse_json(text):
+    """Strict JSON: no duplicate keys, no NaN or Infinity (also none that overflows, such as 1e999), so every value
+    it returns can be written back to the log."""
+
+    return json.loads(text, object_pairs_hook=_unique_pairs, parse_constant=_no_constant, parse_float=_finite_float)
+
+
+def encode_record(seq, tool, args, ok=None):
+    """A log line: ``{"seq", "tool", "args"}``, plus ``"ok"`` (the craft succeeded) for a craft."""
+
+    record = {"seq": seq, "tool": tool, "args": args}
+    if tool == "craft":
+        record["ok"] = bool(ok)
+    return (json.dumps(record, ensure_ascii=True, separators=(",", ":"), allow_nan=False) + "\n").encode("ascii")
+
+
+def check_arguments(tool, args):
+    """``args`` as a log record or a command may give them to ``tool``; ValueError says what is wrong."""
+
+    if not isinstance(args, dict) or sorted(args) != sorted(ARGUMENTS[tool]):
+        raise ValueError("%s takes the arguments %s" % (tool, ", ".join(ARGUMENTS[tool]) or "none"))
+    if tool == "get_info" and (
+        not isinstance(args["items"], list) or not all(isinstance(item, str) for item in args["items"])
+    ):
+        raise ValueError("get_info takes a list of item names")
+    if tool == "finish" and not isinstance(args["message"], str):
+        raise ValueError("finish takes a message string")
+
+
+def _record(line, seq):
+    try:
+        record = parse_json(line.decode("utf-8"))
+    except (UnicodeDecodeError, ValueError, RecursionError) as exc:
+        raise LogError("record %d is not a JSON object: %s" % (seq, exc)) from None
+    if not isinstance(record, dict):
+        raise LogError("record %d is not a JSON object" % seq)
+    tool = record.get("tool")
+    if not isinstance(tool, str) or tool not in ARGUMENTS:
+        raise LogError("record %d names no tool of the game: %r" % (seq, tool))
+    keys = {"seq", "tool", "args", "ok"} if tool == "craft" else {"seq", "tool", "args"}
+    if set(record) != keys:
+        raise LogError("record %d must have exactly the keys %s" % (seq, sorted(keys)))
+    if type(record["seq"]) is not int or record["seq"] != seq:
+        raise LogError("record %d is numbered %r" % (seq, record["seq"]))
+    try:
+        check_arguments(tool, record["args"])
+    except ValueError as exc:
+        raise LogError("record %d: %s" % (seq, exc)) from None
+    if tool == "craft" and not isinstance(record["ok"], bool):
+        raise LogError("record %d: ok must be true or false" % seq)
+    return tool, record["args"], record.get("ok")
+
+
+def replay(game, data):
+    """Apply a log's records to ``game``; how many there were.  LogError at the first record the game could not
+    have written: the replay stops there.
+
+    The records are read one at a time, and those of ``get_info`` and ``view_inventory``, which change nothing, have
+    their arguments checked but their output never rebuilt, so replaying any log within the size cap takes seconds
+    and a bounded amount of memory (a ``get_info`` record can name millions of items)."""
+
+    if not data:
+        return 0
+    if not data.endswith(b"\n"):
+        raise LogError("the last record does not end with a newline")
+    seq = start = 0
+    while start < len(data):
+        end = data.index(b"\n", start)
+        seq += 1
+        if game.finished:
+            raise LogError("record %d follows finish" % seq)
+        tool, args, ok = _record(data[start:end], seq)
+        start = end + 1
+        if tool in READ_ONLY:
+            continue
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:  # arguments no command writes
+            raise LogError("record %d cannot be applied: %s: %s" % (seq, type(exc).__name__, exc)) from None
+        if tool == "craft" and text.startswith(CRAFTED) != ok:
+            claim = "succeeded" if ok else "failed"
+            raise LogError("record %d says the craft %s, but the rules give: %s" % (seq, claim, text))
+    return seq
+
+
+# ---------------------------------------------------------------------------------------------------- the command
+
+
+class UsageError(ValueError):
+    pass
+
+
+class Result:
+    """What a command printed and its exit status: 0 done, 1 a game error (a rejected craft, the episode is over),
+    2 a usage error (nothing was run or logged), 3 the task cannot be played."""
+
+    def __init__(self, code, out="", err=""):
+        self.code = code
+        self.out = out
+        self.err = err
+
+
+def parse_command(argv):
+    """``(tool, args)`` of a command line; UsageError when it is not one."""
+
+    if not argv:
+        raise UsageError("no command")
+    tool = COMMANDS.get(argv[0])
+    if tool is None:
+        raise UsageError("unknown command %r" % argv[0])
+    rest = argv[1:]
+    if tool == "craft":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("craft --json takes one JSON object")
+            args = _json_argument(rest[1])
+            if not isinstance(args, dict) or sorted(args) != ["ingredients", "target"]:
+                raise UsageError('craft --json takes {"ingredients": {...}, "target": [item, count]}')
+            return tool, args
+        if len(rest) < 2:
+            raise UsageError("craft takes TARGET COUNT INGREDIENT=N ...")
+        ingredients = {}
+        for word in rest[2:]:
+            name, sep, count = word.rpartition("=")
+            if not sep or not name:
+                raise UsageError("ingredients are INGREDIENT=N, got %r" % word)
+            if name in ingredients:
+                raise UsageError("ingredient %r is given twice" % name)
+            ingredients[name] = _integer(count, "the count of %s" % name)
+        return tool, {"ingredients": ingredients, "target": [rest[0], _integer(rest[1], "COUNT")]}
+    if tool == "get_info":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("info --json takes one JSON list")
+            items = _json_argument(rest[1])
+        else:
+            items = list(rest)
+        args = {"items": items}
+    elif tool == "view_inventory":
+        if rest:
+            raise UsageError("inventory takes no arguments")
+        args = {}
+    else:
+        if not rest:
+            raise UsageError("finish takes a MESSAGE saying what you achieved")
+        args = {"message": " ".join(rest)}
+    try:
+        check_arguments(tool, args)
+    except ValueError as exc:
+        raise UsageError(str(exc)) from None
+    return tool, args
+
+
+def _json_argument(text):
+    try:
+        return parse_json(text)
+    except (ValueError, RecursionError) as exc:
+        raise UsageError("not valid JSON: %s" % exc) from None
+
+
+def _integer(text, what):
+    try:
+        return int(text)
+    except ValueError:
+        raise UsageError("%s must be an integer, got %r" % (what, text)) from None
+
+
+def default_directory():
+    return os.environ.get("TEXTCRAFT_DIR") or os.path.dirname(os.path.abspath(__file__))
+
+
+def run(argv, directory=None, recipes=None):
+    """Run a command line against the task in ``directory`` (default ``$TEXTCRAFT_DIR``, else this file's
+    directory), with the recipes ``recipes`` (default ``$TEXTCRAFT_RECIPES``, else the directory's
+    ``recipes.json``)."""
+
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        return Result(0 if argv else 2, USAGE)
+    if argv[0] == "--version":
+        return Result(0, "textcraft %s" % VERSION)
+    try:
+        tool, args = parse_command(argv)
+    except UsageError as exc:
+        return Result(2, err="textcraft: %s\n\n%s" % (exc, USAGE))
+    directory = directory or default_directory()
+    try:
+        task = load_task(os.path.join(directory, TASK_FILE))
+        book = RecipeBook.load(recipes or os.environ.get("TEXTCRAFT_RECIPES") or os.path.join(directory, RECIPES_FILE))
+    except (OSError, ValueError, KeyError) as exc:
+        return Result(3, err="textcraft: cannot load the task: %s" % exc)
+    if task["recipes_sha256"] != book.sha256:
+        return Result(3, err="textcraft: the recipes (%s) are not the ones of this task" % book.sha256)
+    path = os.path.join(directory, LOG_FILE)
+    try:
+        fd = os.open(path, os.O_RDWR | os.O_CREAT | os.O_APPEND | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    except OSError as exc:
+        why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+        return Result(3, err="textcraft: cannot open the action log %s: %s" % (path, why))
+    try:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_EX)
+        except OSError:
+            pass  # a file system without locks: commands are not expected to overlap
+        if not stat.S_ISREG(os.fstat(fd).st_mode):
+            return Result(3, err="textcraft: the action log %s is not a regular file" % path)
+        data = _read_all(fd)
+        game = Game(book, task)
+        try:
+            seq = replay(game, data) + 1
+        except LogError as exc:
+            return Result(
+                3, err="textcraft: the action log %s does not replay (%s); the episode cannot continue" % (path, exc)
+            )
+        if game.finished:
+            return Result(
+                1, "Error: the episode is finished (textcraft finish was called); no command is accepted after it"
+            )
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:
+            return Result(2, err="textcraft: cannot run %s: %s: %s" % (tool, type(exc).__name__, exc))
+        ok = text.startswith(CRAFTED)
+        line = encode_record(seq, tool, args, ok)
+        if len(data) + len(line) > LOG_CAP_BYTES:
+            return Result(1, "Error: the action log is full (%d bytes); no command is accepted" % LOG_CAP_BYTES)
+        _write_all(fd, line)
+    finally:
+        os.close(fd)
+    return Result(1 if tool == "craft" and not ok else 0, text)
+
+
+def _read_all(fd):
+    os.lseek(fd, 0, os.SEEK_SET)
+    chunks = []
+    while True:
+        chunk = os.read(fd, 1 << 20)
+        if not chunk:
+            return b"".join(chunks)
+        chunks.append(chunk)
+
+
+def _write_all(fd, data):
+    view = memoryview(data)
+    while view:
+        view = view[os.write(fd, view) :]
+
+
+# ---------------------------------------------------------------------------------------------------- the verifier
+
+
+def read_untrusted(root, relative, cap=LOG_CAP_BYTES):
+    """The bytes of ``root/relative``, reached without following a symbolic link below ``root``; None when it does
+    not exist.  LogError when it is not a regular file, or holds more than ``cap`` bytes."""
+
+    parts = [part for part in relative.split("/") if part not in ("", ".")]
+    if not parts or ".." in parts:
+        raise ValueError("%r is not a path below the root" % relative)
+    directory = os.open(root, os.O_RDONLY | os.O_DIRECTORY | _CLOEXEC)
+    try:
+        for part in parts[:-1]:
+            try:
+                below = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW | _CLOEXEC, dir_fd=directory)
+            except FileNotFoundError:
+                return None
+            except OSError as exc:
+                raise LogError("%s on the way to the action log is not a directory (%s)" % (part, exc.strerror))
+            os.close(directory)
+            directory = below
+        try:
+            fd = os.open(parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK | _CLOEXEC, dir_fd=directory)
+        except FileNotFoundError:
+            return None
+        except OSError as exc:
+            why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+            raise LogError("cannot open the action log: %s" % why)
+    finally:
+        os.close(directory)
+    try:
+        info = os.fstat(fd)
+        if not stat.S_ISREG(info.st_mode):
+            raise LogError("the action log is not a regular file")
+        if info.st_size > cap:
+            raise LogError("the action log holds %d bytes; the limit is %d" % (info.st_size, cap))
+        chunks, total = [], 0
+        while total <= cap:
+            chunk = os.read(fd, min(1 << 20, cap + 1 - total))
+            if not chunk:
+                break
+            chunks.append(chunk)
+            total += len(chunk)
+        if total > cap:
+            raise LogError("the action log holds more than %d bytes" % cap)
+        return b"".join(chunks)
+    finally:
+        os.close(fd)
+
+
+def verify(task_path, recipes_path, root, log, out=None):
+    """Grade the log at ``root/log`` against the trusted task and recipes; the verdict (``reward`` and why).
+    Writes ``reward.json`` and ``textcraft-verdict.json`` into ``out`` when given."""
+
+    task = load_task(task_path)
+    book = RecipeBook.load(recipes_path)
+    if task["recipes_sha256"] != book.sha256:
+        raise ValueError("the verifier's recipes %s are not the task's %s" % (book.sha256, task["recipes_sha256"]))
+    game = Game(book, task)
+    verdict = {"reward": 0.0, "task": task["name"], "version": VERSION, "records": 0, "crafts": 0, "finished": False}
+    try:
+        data = read_untrusted(root, log)
+        if data is None:
+            verdict["reason"] = "no action log: no textcraft command ran"
+        else:
+            verdict["log_bytes"] = len(data)
+            verdict["records"] = replay(game, data)
+            verdict["crafts"] = game.crafts
+            verdict["finished"] = game.finished
+            if not game.finished:
+                verdict["reason"] = "the episode did not end with textcraft finish"
+            elif game.score >= 1.0:
+                verdict["reward"] = 1.0
+                verdict["reason"] = "finished with every target crafted"
+            elif game.reward_misc.get("missing_items"):
+                verdict["reason"] = "finished without every target crafted"
+                verdict["missing_items"] = game.reward_misc["missing_items"]
+            else:
+                verdict["reason"] = "finished with an empty message"
+    except LogError as exc:
+        verdict["reason"] = "the action log is not one the game wrote: %s" % exc
+    if out is not None:
+        _write_new(out, VERDICT_FILE, json.dumps(verdict, indent=1, sort_keys=True) + "\n")
+        _write_new(out, REWARD_FILE, json.dumps({"reward": verdict["reward"]}) + "\n")
+    return verdict
+
+
+def _write_new(directory, name, text):
+    """Write ``directory/name`` through a new file and a rename, so the name ends up a regular file whatever was
+    there."""
+
+    temporary = os.path.join(directory, ".%s.%d.tmp" % (name, os.getpid()))
+    fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    try:
+        _write_all(fd, text.encode("utf-8"))
+        os.fsync(fd)
+    finally:
+        os.close(fd)
+    os.replace(temporary, os.path.join(directory, name))
+
+
+def verify_main(argv):
+    parser = argparse.ArgumentParser(prog="textcraft_game.py verify", description="Grade a TextCraft action log.")
+    parser.add_argument("--task", required=True, help="the trusted task.json")
+    parser.add_argument("--recipes", required=True, help="the trusted recipes.json")
+    parser.add_argument("--root", required=True, help="the sandbox root the log path is below")
+    parser.add_argument("--log", required=True, help="the log's path below the root")
+    parser.add_argument("--out", required=True, help="the verifier's output directory (reward.json)")
+    options = parser.parse_args(argv)
+    try:
+        verdict = verify(options.task, options.recipes, options.root, options.log, options.out)
+    except (OSError, ValueError, KeyError) as exc:
+        print("textcraft verify: cannot grade: %s" % exc, file=sys.stderr)
+        return 1
+    print(
+        "reward %g: %s (%d records, %d crafts)"
+        % (verdict["reward"], verdict["reason"], verdict["records"], verdict["crafts"])
+    )
+    return 0
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv[:1] == ["verify"]:
+        return verify_main(argv[1:])
+    result = run(argv)
+    if result.out:
+        print(result.out)
+    if result.err:
+        print(result.err, file=sys.stderr)
+    return result.code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/textcraft-synth-train-easy-00629/environment/Dockerfile

@@ -0,0 +1,17 @@
+# textcraft-synth-train-easy-00629: task.json sha256:a51761f978e9574b759b363fd1785a214f18d812d2166346dc6eef34d9673df5
+FROM docker.io/library/python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1
+# The image is the same for every task (and for the verifier): Python, tmux for terminal agents, and the
+# `textcraft` command, which runs the game file below.
+RUN set -eux; \
+    printf '#!/bin/sh\nexec python3 -I /app/textcraft/textcraft_game.py "$@"\n' \
+        > /usr/local/bin/textcraft; \
+    chmod 0755 /usr/local/bin/textcraft; \
+    apt-get -o APT::Sandbox::User=root update; \
+    apt-get -o APT::Sandbox::User=root install -y --no-install-recommends tmux; \
+    rm -rf /var/lib/apt/lists/*
+# The game and the world's recipes (the same in every task), then this task's goal and starting inventory.  The
+# game keeps its action log next to them.
+WORKDIR /app
+ENV TEXTCRAFT_DIR=/app/textcraft
+COPY textcraft_game.py recipes.json /app/textcraft/
+COPY task.json /app/textcraft/

tasks/textcraft-synth-train-easy-00629/environment/task.json

@@ -0,0 +1,15 @@
+{
+ "format": "textcraft-task/1",
+ "name": "textcraft-synth-train-easy-00629",
+ "world": "textcraft-synth",
+ "goal": "Craft the following items: 1x t4_i2",
+ "target_items": {
+  "t4_i2": 1
+ },
+ "initial_inventory": {
+  "raw_t8": 1,
+  "raw_t9": 2,
+  "raw_t2": 2
+ },
+ "recipes_sha256": "a020eec273337c66b35c0fc487664e35c44da65ad18e9afffe6a4c25af949f10"
+}

tasks/textcraft-synth-train-easy-00629/environment/textcraft_game.py

@@ -0,0 +1,756 @@
+"""TextCraft in a container: the ``textcraft`` command of a Harbor task, and the verifier that grades it.
+
+This one file is the whole game.  It needs Python 3.8 or later and its standard library only, and it never imports
+platoon: the exporter (``python -m platoon.textcraft.harbor export``) copies it into every task as
+``textcraft_game.py``, into ``environment/`` (the container gets it at ``/app/textcraft/textcraft_game.py``, which
+the image's ``textcraft`` command runs) and into ``tests/`` for the verifier.  It reproduces platoon's TextCraft
+environments (``platoon.textcraft.env``): the same four tools with the same arguments, the same observation text
+and the same success rule.
+
+=========================================  ===================  ===============================================
+command                                    environment tool     prints
+=========================================  ===================  ===============================================
+``textcraft craft TARGET COUNT ING=N ...``  ``craft``            ``Successfully crafted ...`` or ``Error: ...``
+``textcraft info ITEM ...``                 ``get_info``         the recipe information, as JSON
+``textcraft inventory``                     ``view_inventory``   the inventory, as JSON
+``textcraft finish MESSAGE``                ``finish``           the message; the episode ends
+=========================================  ===================  ===============================================
+
+``craft --json '{"ingredients": {...}, "target": [item, count]}'`` and ``info --json '[item, ...]'`` take a tool's
+arguments as JSON values, the way a tool call passes them.
+
+**State.**  ``$TEXTCRAFT_DIR`` (default: this file's directory, ``/app/textcraft`` in a task's container) holds the
+task (``task.json``: goal, targets, starting inventory), the world's recipes (``recipes.json``, or
+``$TEXTCRAFT_RECIPES``) and the action log (``actions.jsonl``).  The log is the state: under an exclusive lock,
+every command replays the log from the starting inventory, runs, and appends its own record (``{"seq", "tool",
+"args"}``, plus ``"ok"`` for a craft).  Nothing is accepted after ``finish``, or once the log no longer replays.
+
+**Grading** (``python3 textcraft_game.py verify``, from the task's ``tests/test.sh``) replays the log with trusted
+copies of the task and the recipes.  The reward is 1 when the log is an episode the rules allow that ends in
+``finish`` with a message, and the inventory then holds every target count on top of the starting inventory (the
+environment's rule); otherwise it is 0.  The log must be a regular file of at most 32 MiB, reached without a
+symbolic link below the sandbox root.  A record that does not parse, breaks the record format or the numbering,
+follows ``finish``, or claims a craft outcome the rules do not give ends the replay with reward 0: only a log the
+command could have written earns a reward.  A craft the rules reject, recorded as rejected, changes nothing, as in
+the environment.
+"""
+
+from __future__ import annotations
+
+import argparse
+import errno
+import fcntl
+import hashlib
+import json
+import os
+import stat
+import sys
+
+VERSION = "1.0"
+TASK_FORMAT = "textcraft-task/1"
+RECIPES_FORMAT = "textcraft-recipes/1"
+TASK_FILE = "task.json"
+LOG_FILE = "actions.jsonl"
+RECIPES_FILE = "recipes.json"
+REWARD_FILE = "reward.json"
+VERDICT_FILE = "textcraft-verdict.json"
+LOG_CAP_BYTES = 32 * 1024 * 1024
+CRAFTED = "Successfully crafted"
+# The environment's tools and their arguments, as a log record names them.
+ARGUMENTS = {"craft": ("ingredients", "target"), "get_info": ("items",), "view_inventory": (), "finish": ("message",)}
+READ_ONLY = frozenset({"get_info", "view_inventory"})  # tools that change nothing
+COMMANDS = {
+    "craft": "craft",
+    "info": "get_info",
+    "get_info": "get_info",
+    "inventory": "view_inventory",
+    "view_inventory": "view_inventory",
+    "finish": "finish",
+}
+_CLOEXEC = getattr(os, "O_CLOEXEC", 0)
+
+USAGE = """\
+usage: textcraft COMMAND [ARGUMENTS]
+
+Play the TextCraft task in $TEXTCRAFT_DIR (default /app/textcraft, the game's directory).
+
+  textcraft craft TARGET COUNT INGREDIENT=N [INGREDIENT=N ...]
+      Craft COUNT of TARGET from exactly these ingredients.  COUNT must be divisible by the recipe's
+      result_count; each ingredient's N is its recipe count times COUNT / result_count.
+      Example: textcraft craft m2_i2 2 m0_i1=2 m1_i1=1
+  textcraft info ITEM [ITEM ...]
+      Recipe information for the items, as a JSON list.
+  textcraft inventory
+      Your current inventory, as JSON {item_name: count}.
+  textcraft finish MESSAGE
+      Complete the task with a message saying what you achieved.  The task is graded on what your
+      inventory gained; no command is accepted after it.
+
+craft --json '{"ingredients": {...}, "target": [item, count]}' and info --json '[item, ...]' take the
+arguments as JSON.  get_info and view_inventory are other names for info and inventory.
+"""
+
+
+# ---------------------------------------------------------------------------------------------------- the world
+
+
+class Recipe:
+    __slots__ = ("result_count", "ingredients")
+
+    def __init__(self, result_count, ingredients):
+        self.result_count = result_count
+        self.ingredients = ingredients  # {item or "tag:<name>": count}, in the recipe's order
+
+
+class RecipeBook:
+    """A world's recipes (``recipes.json``), with the lookups of platoon's recipe databases.
+
+    The file lists each craftable item's recipes (ingredients as ``[name, count]`` pairs, in order), the base items,
+    every item's crafting depth (0 for items it does not list) and the items each ``tag:<name>`` ingredient accepts.
+    """
+
+    def __init__(self, data, sha256=None):
+        if not isinstance(data, dict) or data.get("format") != RECIPES_FORMAT:
+            raise ValueError("not a %s file" % RECIPES_FORMAT)
+        self.name = data["name"]
+        self.sha256 = sha256
+        self.recipes = {
+            item: [
+                Recipe(recipe["result_count"], {name: count for name, count in recipe["ingredients"]})
+                for recipe in recipes
+            ]
+            for item, recipes in data["recipes"].items()
+        }
+        self.base_items = frozenset(data["base_items"])
+        self.depths = dict(data["depths"])
+        self.tags = {tag: list(items) for tag, items in data["tags"].items()}
+
+    @classmethod
+    def load(cls, path):
+        with open(path, "rb") as handle:
+            raw = handle.read()
+        return cls(json.loads(raw.decode("utf-8")), sha256=hashlib.sha256(raw).hexdigest())
+
+    def get_recipes_for_item(self, item):
+        return self.recipes.get(item, [])
+
+    def can_craft(self, item):
+        return item in self.recipes
+
+    def is_base_item(self, item):
+        return item in self.base_items
+
+    def get_crafting_depth(self, item):
+        return self.depths.get(item, 0)
+
+    def get_items_for_tag(self, tag):
+        return list(self.tags.get(tag, []))
+
+
+def load_task(path):
+    """A task file (``task.json``): its goal, targets and starting inventory, and its recipes' SHA-256."""
+
+    with open(path, "rb") as handle:
+        task = json.loads(handle.read().decode("utf-8"))
+    if not isinstance(task, dict) or task.get("format") != TASK_FORMAT:
+        raise ValueError("%s is not a %s file" % (path, TASK_FORMAT))
+    for key in ("name", "goal", "target_items", "initial_inventory", "recipes_sha256"):
+        if key not in task:
+            raise ValueError("%s has no %r" % (path, key))
+    return task
+
+
+# ---------------------------------------------------------------------------------------------------- the game
+
+
+class Game:
+    """One episode: platoon's ``TextCraftEnvironment`` tools over an inventory, its rules and messages unchanged."""
+
+    def __init__(self, book, task):
+        self.book = book
+        self.goal = task["goal"]
+        self.target_items = dict(task["target_items"])
+        self.inventory = dict(task["initial_inventory"])
+        self.initial_inventory = dict(self.inventory)
+        self.finished = False
+        self.score = 0.0
+        self.reward_misc = {}
+        self.crafts = 0  # successful crafts
+
+    def call(self, tool, args):
+        """Run a tool with its arguments (the JSON values a tool call carries); the observation text it returns."""
+
+        if tool == "craft":
+            text = self.craft(args["ingredients"], args["target"])
+            self.crafts += text.startswith(CRAFTED)
+            return text
+        if tool == "get_info":
+            return json.dumps(self.get_info(args["items"]))
+        if tool == "view_inventory":
+            return json.dumps(dict(self.inventory))
+        if tool == "finish":
+            self.score, self.reward_misc = self.evaluate(args["message"])
+            self.finished = True
+            return args["message"]
+        raise ValueError("unknown tool %r" % (tool,))
+
+    def craft(self, ingredients, target):
+        """``TextCraftEnvironment._craft``: the same checks in the same order, with the same messages."""
+
+        if not isinstance(ingredients, dict):
+            return f"Error: ingredients must be a dict, got {type(ingredients).__name__}"
+        if not isinstance(target, (tuple, list)) or len(target) != 2:
+            return "Error: target must be a tuple of (item_name, count)"
+        target_item, target_count = target
+        if not isinstance(target_item, str):
+            return f"Error: target item must be a string, got {type(target_item).__name__}"
+        if not isinstance(target_count, int):
+            return f"Error: target count must be an int, got {type(target_count).__name__}"
+        if target_count <= 0:
+            return f"Error: target count must be positive, got {target_count}"
+        for ing_item, ing_count in ingredients.items():
+            if not isinstance(ing_item, str):
+                return f"Error: ingredient name must be a string, got {type(ing_item).__name__}"
+            if not isinstance(ing_count, int):
+                return f"Error: ingredient count for {ing_item} must be an int, got {type(ing_count).__name__}"
+            if ing_count <= 0:
+                return f"Error: ingredient count for {ing_item} must be positive, got {ing_count}"
+
+        book = self.book
+        recipes = book.get_recipes_for_item(target_item)
+        if not recipes:
+            return f"Error: No recipe found for {target_item}"
+
+        errors = []
+        for recipe_idx, recipe in enumerate(recipes):
+            if target_count % recipe.result_count != 0:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Target count {target_count} is not divisible "
+                    f"by recipe result count {recipe.result_count}"
+                )
+                continue
+            num_crafts = target_count // recipe.result_count
+
+            ingredient_mapping = {}  # recipe ingredient (or tag) -> provided item
+            recipe_error = None
+            for recipe_ing, recipe_count in recipe.ingredients.items():
+                total_required = recipe_count * num_crafts
+                if recipe_ing.startswith("tag:"):
+                    satisfying_items = book.get_items_for_tag(recipe_ing.replace("tag:", ""))
+                    provided = next(
+                        (
+                            item
+                            for item, count in ingredients.items()
+                            if item in satisfying_items and count == total_required
+                        ),
+                        None,
+                    )
+                    if provided is None:
+                        recipe_error = f"No ingredient provided for {recipe_ing}. Expected one of: {satisfying_items}"
+                        break
+                    ingredient_mapping[recipe_ing] = provided
+                else:
+                    if recipe_ing not in ingredients:
+                        recipe_error = f"Missing required ingredient {recipe_ing}"
+                        break
+                    if ingredients[recipe_ing] != total_required:
+                        recipe_error = (
+                            f"Wrong amount of {recipe_ing}. Need {total_required}, provided {ingredients[recipe_ing]}"
+                        )
+                        break
+                    ingredient_mapping[recipe_ing] = recipe_ing
+            if recipe_error:
+                errors.append(f"Recipe {recipe_idx + 1}: {recipe_error}")
+                continue
+
+            extra_ingredients = [item for item in ingredients if item not in ingredient_mapping.values()]
+            if extra_ingredients:
+                errors.append(
+                    f"Recipe {recipe_idx + 1}: Extra ingredients not required: {', '.join(extra_ingredients)}"
+                )
+                continue
+
+            missing = []
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                required = recipe.ingredients[recipe_ing] * num_crafts
+                available = self.inventory.get(provided_ing, 0)
+                if available < required:
+                    missing.append(f"{provided_ing}: need {required}, have {available}")
+            if missing:
+                errors.append(f"Recipe {recipe_idx + 1}: Insufficient ingredients in inventory: {', '.join(missing)}")
+                continue
+
+            for recipe_ing, provided_ing in ingredient_mapping.items():
+                self.inventory[provided_ing] -= recipe.ingredients[recipe_ing] * num_crafts
+                if self.inventory[provided_ing] <= 0:
+                    del self.inventory[provided_ing]
+            crafted_count = recipe.result_count * num_crafts
+            self.inventory[target_item] = self.inventory.get(target_item, 0) + crafted_count
+            return f"Successfully crafted {crafted_count} {target_item}(s)"
+
+        return f"Error: All {len(recipes)} recipe(s) failed for {target_item}. Errors:\n" + "\n".join(errors)
+
+    def get_info(self, items):
+        """``TextCraftEnvironment._get_info``."""
+
+        book = self.book
+        results = []
+        for item in items:
+            info = {
+                "item": item,
+                "can_craft": book.can_craft(item),
+                "is_base": book.is_base_item(item),
+                "in_inventory": self.inventory.get(item, 0),
+                "crafting_depth": book.get_crafting_depth(item),
+                "recipes": [],
+            }
+            if info["can_craft"]:
+                for recipe in book.get_recipes_for_item(item):
+                    expanded = {}
+                    for ing, count in recipe.ingredients.items():
+                        if ing.startswith("tag:"):
+                            expanded[ing] = {"count": count, "use_one_of": book.get_items_for_tag(ing[4:])}
+                        else:
+                            expanded[ing] = count
+                    info["recipes"].append({"ingredients": expanded, "result_count": recipe.result_count})
+            results.append(info)
+        return results
+
+    def evaluate(self, finish_message):
+        """``TextCraftEnvironment.evaluate``: success when the inventory gained every target count and the finish
+        message is not empty."""
+
+        reward_misc = {}
+        score = 0.0
+        if finish_message:
+            if not self.target_items:
+                return 0.0, {"success": False, "error": "No target items defined in task", "reward/success": 0.0}
+            missing = {
+                item: required - (self.inventory.get(item, 0) - self.initial_inventory.get(item, 0))
+                for item, required in self.target_items.items()
+                if self.inventory.get(item, 0) - self.initial_inventory.get(item, 0) < required
+            }
+            reward_misc["success"] = not missing
+            if missing:
+                reward_misc["missing_items"] = missing
+            else:
+                score = 1.0
+            reward_misc["target_items"] = dict(self.target_items)
+            reward_misc["initial_inventory"] = dict(self.initial_inventory)
+            reward_misc["final_inventory"] = dict(self.inventory)
+        else:
+            reward_misc["success"] = False
+            reward_misc["error"] = "Episode ended without calling finish() - likely timeout or max steps reached"
+        reward_misc["reward/success"] = score
+        return score, reward_misc
+
+
+# ---------------------------------------------------------------------------------------------------- the log
+
+
+class LogError(ValueError):
+    """An action log the game could not have written: its replay stops there."""
+
+
+def _unique_pairs(pairs):
+    found = {}
+    for key, value in pairs:
+        if key in found:
+            raise ValueError("duplicate key %r" % (key,))
+        found[key] = value
+    return found
+
+
+def _no_constant(name):
+    raise ValueError("%s is not a JSON number" % name)
+
+
+def _finite_float(text):
+    value = float(text)
+    if value != value or value in (float("inf"), float("-inf")):
+        raise ValueError("%s is out of range" % text)
+    return value
+
+
+def parse_json(text):
+    """Strict JSON: no duplicate keys, no NaN or Infinity (also none that overflows, such as 1e999), so every value
+    it returns can be written back to the log."""
+
+    return json.loads(text, object_pairs_hook=_unique_pairs, parse_constant=_no_constant, parse_float=_finite_float)
+
+
+def encode_record(seq, tool, args, ok=None):
+    """A log line: ``{"seq", "tool", "args"}``, plus ``"ok"`` (the craft succeeded) for a craft."""
+
+    record = {"seq": seq, "tool": tool, "args": args}
+    if tool == "craft":
+        record["ok"] = bool(ok)
+    return (json.dumps(record, ensure_ascii=True, separators=(",", ":"), allow_nan=False) + "\n").encode("ascii")
+
+
+def check_arguments(tool, args):
+    """``args`` as a log record or a command may give them to ``tool``; ValueError says what is wrong."""
+
+    if not isinstance(args, dict) or sorted(args) != sorted(ARGUMENTS[tool]):
+        raise ValueError("%s takes the arguments %s" % (tool, ", ".join(ARGUMENTS[tool]) or "none"))
+    if tool == "get_info" and (
+        not isinstance(args["items"], list) or not all(isinstance(item, str) for item in args["items"])
+    ):
+        raise ValueError("get_info takes a list of item names")
+    if tool == "finish" and not isinstance(args["message"], str):
+        raise ValueError("finish takes a message string")
+
+
+def _record(line, seq):
+    try:
+        record = parse_json(line.decode("utf-8"))
+    except (UnicodeDecodeError, ValueError, RecursionError) as exc:
+        raise LogError("record %d is not a JSON object: %s" % (seq, exc)) from None
+    if not isinstance(record, dict):
+        raise LogError("record %d is not a JSON object" % seq)
+    tool = record.get("tool")
+    if not isinstance(tool, str) or tool not in ARGUMENTS:
+        raise LogError("record %d names no tool of the game: %r" % (seq, tool))
+    keys = {"seq", "tool", "args", "ok"} if tool == "craft" else {"seq", "tool", "args"}
+    if set(record) != keys:
+        raise LogError("record %d must have exactly the keys %s" % (seq, sorted(keys)))
+    if type(record["seq"]) is not int or record["seq"] != seq:
+        raise LogError("record %d is numbered %r" % (seq, record["seq"]))
+    try:
+        check_arguments(tool, record["args"])
+    except ValueError as exc:
+        raise LogError("record %d: %s" % (seq, exc)) from None
+    if tool == "craft" and not isinstance(record["ok"], bool):
+        raise LogError("record %d: ok must be true or false" % seq)
+    return tool, record["args"], record.get("ok")
+
+
+def replay(game, data):
+    """Apply a log's records to ``game``; how many there were.  LogError at the first record the game could not
+    have written: the replay stops there.
+
+    The records are read one at a time, and those of ``get_info`` and ``view_inventory``, which change nothing, have
+    their arguments checked but their output never rebuilt, so replaying any log within the size cap takes seconds
+    and a bounded amount of memory (a ``get_info`` record can name millions of items)."""
+
+    if not data:
+        return 0
+    if not data.endswith(b"\n"):
+        raise LogError("the last record does not end with a newline")
+    seq = start = 0
+    while start < len(data):
+        end = data.index(b"\n", start)
+        seq += 1
+        if game.finished:
+            raise LogError("record %d follows finish" % seq)
+        tool, args, ok = _record(data[start:end], seq)
+        start = end + 1
+        if tool in READ_ONLY:
+            continue
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:  # arguments no command writes
+            raise LogError("record %d cannot be applied: %s: %s" % (seq, type(exc).__name__, exc)) from None
+        if tool == "craft" and text.startswith(CRAFTED) != ok:
+            claim = "succeeded" if ok else "failed"
+            raise LogError("record %d says the craft %s, but the rules give: %s" % (seq, claim, text))
+    return seq
+
+
+# ---------------------------------------------------------------------------------------------------- the command
+
+
+class UsageError(ValueError):
+    pass
+
+
+class Result:
+    """What a command printed and its exit status: 0 done, 1 a game error (a rejected craft, the episode is over),
+    2 a usage error (nothing was run or logged), 3 the task cannot be played."""
+
+    def __init__(self, code, out="", err=""):
+        self.code = code
+        self.out = out
+        self.err = err
+
+
+def parse_command(argv):
+    """``(tool, args)`` of a command line; UsageError when it is not one."""
+
+    if not argv:
+        raise UsageError("no command")
+    tool = COMMANDS.get(argv[0])
+    if tool is None:
+        raise UsageError("unknown command %r" % argv[0])
+    rest = argv[1:]
+    if tool == "craft":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("craft --json takes one JSON object")
+            args = _json_argument(rest[1])
+            if not isinstance(args, dict) or sorted(args) != ["ingredients", "target"]:
+                raise UsageError('craft --json takes {"ingredients": {...}, "target": [item, count]}')
+            return tool, args
+        if len(rest) < 2:
+            raise UsageError("craft takes TARGET COUNT INGREDIENT=N ...")
+        ingredients = {}
+        for word in rest[2:]:
+            name, sep, count = word.rpartition("=")
+            if not sep or not name:
+                raise UsageError("ingredients are INGREDIENT=N, got %r" % word)
+            if name in ingredients:
+                raise UsageError("ingredient %r is given twice" % name)
+            ingredients[name] = _integer(count, "the count of %s" % name)
+        return tool, {"ingredients": ingredients, "target": [rest[0], _integer(rest[1], "COUNT")]}
+    if tool == "get_info":
+        if rest[:1] == ["--json"]:
+            if len(rest) != 2:
+                raise UsageError("info --json takes one JSON list")
+            items = _json_argument(rest[1])
+        else:
+            items = list(rest)
+        args = {"items": items}
+    elif tool == "view_inventory":
+        if rest:
+            raise UsageError("inventory takes no arguments")
+        args = {}
+    else:
+        if not rest:
+            raise UsageError("finish takes a MESSAGE saying what you achieved")
+        args = {"message": " ".join(rest)}
+    try:
+        check_arguments(tool, args)
+    except ValueError as exc:
+        raise UsageError(str(exc)) from None
+    return tool, args
+
+
+def _json_argument(text):
+    try:
+        return parse_json(text)
+    except (ValueError, RecursionError) as exc:
+        raise UsageError("not valid JSON: %s" % exc) from None
+
+
+def _integer(text, what):
+    try:
+        return int(text)
+    except ValueError:
+        raise UsageError("%s must be an integer, got %r" % (what, text)) from None
+
+
+def default_directory():
+    return os.environ.get("TEXTCRAFT_DIR") or os.path.dirname(os.path.abspath(__file__))
+
+
+def run(argv, directory=None, recipes=None):
+    """Run a command line against the task in ``directory`` (default ``$TEXTCRAFT_DIR``, else this file's
+    directory), with the recipes ``recipes`` (default ``$TEXTCRAFT_RECIPES``, else the directory's
+    ``recipes.json``)."""
+
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        return Result(0 if argv else 2, USAGE)
+    if argv[0] == "--version":
+        return Result(0, "textcraft %s" % VERSION)
+    try:
+        tool, args = parse_command(argv)
+    except UsageError as exc:
+        return Result(2, err="textcraft: %s\n\n%s" % (exc, USAGE))
+    directory = directory or default_directory()
+    try:
+        task = load_task(os.path.join(directory, TASK_FILE))
+        book = RecipeBook.load(recipes or os.environ.get("TEXTCRAFT_RECIPES") or os.path.join(directory, RECIPES_FILE))
+    except (OSError, ValueError, KeyError) as exc:
+        return Result(3, err="textcraft: cannot load the task: %s" % exc)
+    if task["recipes_sha256"] != book.sha256:
+        return Result(3, err="textcraft: the recipes (%s) are not the ones of this task" % book.sha256)
+    path = os.path.join(directory, LOG_FILE)
+    try:
+        fd = os.open(path, os.O_RDWR | os.O_CREAT | os.O_APPEND | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    except OSError as exc:
+        why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+        return Result(3, err="textcraft: cannot open the action log %s: %s" % (path, why))
+    try:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_EX)
+        except OSError:
+            pass  # a file system without locks: commands are not expected to overlap
+        if not stat.S_ISREG(os.fstat(fd).st_mode):
+            return Result(3, err="textcraft: the action log %s is not a regular file" % path)
+        data = _read_all(fd)
+        game = Game(book, task)
+        try:
+            seq = replay(game, data) + 1
+        except LogError as exc:
+            return Result(
+                3, err="textcraft: the action log %s does not replay (%s); the episode cannot continue" % (path, exc)
+            )
+        if game.finished:
+            return Result(
+                1, "Error: the episode is finished (textcraft finish was called); no command is accepted after it"
+            )
+        try:
+            text = game.call(tool, args)
+        except Exception as exc:
+            return Result(2, err="textcraft: cannot run %s: %s: %s" % (tool, type(exc).__name__, exc))
+        ok = text.startswith(CRAFTED)
+        line = encode_record(seq, tool, args, ok)
+        if len(data) + len(line) > LOG_CAP_BYTES:
+            return Result(1, "Error: the action log is full (%d bytes); no command is accepted" % LOG_CAP_BYTES)
+        _write_all(fd, line)
+    finally:
+        os.close(fd)
+    return Result(1 if tool == "craft" and not ok else 0, text)
+
+
+def _read_all(fd):
+    os.lseek(fd, 0, os.SEEK_SET)
+    chunks = []
+    while True:
+        chunk = os.read(fd, 1 << 20)
+        if not chunk:
+            return b"".join(chunks)
+        chunks.append(chunk)
+
+
+def _write_all(fd, data):
+    view = memoryview(data)
+    while view:
+        view = view[os.write(fd, view) :]
+
+
+# ---------------------------------------------------------------------------------------------------- the verifier
+
+
+def read_untrusted(root, relative, cap=LOG_CAP_BYTES):
+    """The bytes of ``root/relative``, reached without following a symbolic link below ``root``; None when it does
+    not exist.  LogError when it is not a regular file, or holds more than ``cap`` bytes."""
+
+    parts = [part for part in relative.split("/") if part not in ("", ".")]
+    if not parts or ".." in parts:
+        raise ValueError("%r is not a path below the root" % relative)
+    directory = os.open(root, os.O_RDONLY | os.O_DIRECTORY | _CLOEXEC)
+    try:
+        for part in parts[:-1]:
+            try:
+                below = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW | _CLOEXEC, dir_fd=directory)
+            except FileNotFoundError:
+                return None
+            except OSError as exc:
+                raise LogError("%s on the way to the action log is not a directory (%s)" % (part, exc.strerror))
+            os.close(directory)
+            directory = below
+        try:
+            fd = os.open(parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK | _CLOEXEC, dir_fd=directory)
+        except FileNotFoundError:
+            return None
+        except OSError as exc:
+            why = "it is a symbolic link" if exc.errno == errno.ELOOP else exc.strerror
+            raise LogError("cannot open the action log: %s" % why)
+    finally:
+        os.close(directory)
+    try:
+        info = os.fstat(fd)
+        if not stat.S_ISREG(info.st_mode):
+            raise LogError("the action log is not a regular file")
+        if info.st_size > cap:
+            raise LogError("the action log holds %d bytes; the limit is %d" % (info.st_size, cap))
+        chunks, total = [], 0
+        while total <= cap:
+            chunk = os.read(fd, min(1 << 20, cap + 1 - total))
+            if not chunk:
+                break
+            chunks.append(chunk)
+            total += len(chunk)
+        if total > cap:
+            raise LogError("the action log holds more than %d bytes" % cap)
+        return b"".join(chunks)
+    finally:
+        os.close(fd)
+
+
+def verify(task_path, recipes_path, root, log, out=None):
+    """Grade the log at ``root/log`` against the trusted task and recipes; the verdict (``reward`` and why).
+    Writes ``reward.json`` and ``textcraft-verdict.json`` into ``out`` when given."""
+
+    task = load_task(task_path)
+    book = RecipeBook.load(recipes_path)
+    if task["recipes_sha256"] != book.sha256:
+        raise ValueError("the verifier's recipes %s are not the task's %s" % (book.sha256, task["recipes_sha256"]))
+    game = Game(book, task)
+    verdict = {"reward": 0.0, "task": task["name"], "version": VERSION, "records": 0, "crafts": 0, "finished": False}
+    try:
+        data = read_untrusted(root, log)
+        if data is None:
+            verdict["reason"] = "no action log: no textcraft command ran"
+        else:
+            verdict["log_bytes"] = len(data)
+            verdict["records"] = replay(game, data)
+            verdict["crafts"] = game.crafts
+            verdict["finished"] = game.finished
+            if not game.finished:
+                verdict["reason"] = "the episode did not end with textcraft finish"
+            elif game.score >= 1.0:
+                verdict["reward"] = 1.0
+                verdict["reason"] = "finished with every target crafted"
+            elif game.reward_misc.get("missing_items"):
+                verdict["reason"] = "finished without every target crafted"
+                verdict["missing_items"] = game.reward_misc["missing_items"]
+            else:
+                verdict["reason"] = "finished with an empty message"
+    except LogError as exc:
+        verdict["reason"] = "the action log is not one the game wrote: %s" % exc
+    if out is not None:
+        _write_new(out, VERDICT_FILE, json.dumps(verdict, indent=1, sort_keys=True) + "\n")
+        _write_new(out, REWARD_FILE, json.dumps({"reward": verdict["reward"]}) + "\n")
+    return verdict
+
+
+def _write_new(directory, name, text):
+    """Write ``directory/name`` through a new file and a rename, so the name ends up a regular file whatever was
+    there."""
+
+    temporary = os.path.join(directory, ".%s.%d.tmp" % (name, os.getpid()))
+    fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | _CLOEXEC, 0o644)
+    try:
+        _write_all(fd, text.encode("utf-8"))
+        os.fsync(fd)
+    finally:
+        os.close(fd)
+    os.replace(temporary, os.path.join(directory, name))
+
+
+def verify_main(argv):
+    parser = argparse.ArgumentParser(prog="textcraft_game.py verify", description="Grade a TextCraft action log.")
+    parser.add_argument("--task", required=True, help="the trusted task.json")
+    parser.add_argument("--recipes", required=True, help="the trusted recipes.json")
+    parser.add_argument("--root", required=True, help="the sandbox root the log path is below")
+    parser.add_argument("--log", required=True, help="the log's path below the root")
+    parser.add_argument("--out", required=True, help="the verifier's output directory (reward.json)")
+    options = parser.parse_args(argv)
+    try:
+        verdict = verify(options.task, options.recipes, options.root, options.log, options.out)
+    except (OSError, ValueError, KeyError) as exc:
+        print("textcraft verify: cannot grade: %s" % exc, file=sys.stderr)
+        return 1
+    print(
+        "reward %g: %s (%d records, %d crafts)"
+        % (verdict["reward"], verdict["reason"], verdict["records"], verdict["crafts"])
+    )
+    return 0
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv[:1] == ["verify"]:
+        return verify_main(argv[1:])
+    result = run(argv)
+    if result.out:
+        print(result.out)
+    if result.err:
+        print(result.err, file=sys.stderr)
+    return result.code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/textcraft-synth-train-easy-00629/instruction.md

@@ -0,0 +1,38 @@
+You are an agent in a crafting game. Your goal is to craft items by combining ingredients.
+You have access to an inventory of existing ingredients, which are sufficient to craft the target items; though, you may need to craft intermediate ingredients first.
+
+Note: If you already have one of the target items in your inventory, you should craft the requested number of the target on top of what you already have.
+For example, if you already have 2 wooden_pickaxes but your goal is to craft 3, your inventory should end up with 5 wooden_pickaxes.
+
+## Task
+
+Craft the following items: 1x t4_i2
+
+## Actions
+
+You act through the `textcraft` command in the shell:
+
+1. `textcraft craft TARGET TOTAL_COUNT INGREDIENT=COUNT [INGREDIENT=COUNT ...]`
+   Craft items using ingredients from your inventory.
+   - INGREDIENT=COUNT pairs: the items to consume and how many of each
+   - TARGET TOTAL_COUNT: the item to craft and its total count, which must be divisible by the recipe's result_count
+   - Example: `textcraft craft m2_i2 2 m0_i1=2 m1_i1=1`
+
+2. `textcraft info ITEM [ITEM ...]`
+   Get recipe information for items.
+   - Prints a JSON list with {"item": str, "can_craft": bool, "is_base": bool, "in_inventory": int, "crafting_depth": int, "recipes": [...]}
+   - crafting_depth indicates complexity: 0=base item, 1=direct craft, 2+=needs intermediate steps
+   - Each recipe shows {"ingredients": {...}, "result_count": int}
+   - Example: `textcraft info m2_i2 raw_m0`
+
+3. `textcraft inventory`
+   View your current inventory.
+   - Prints JSON {item_name: count}
+
+4. `textcraft finish MESSAGE`
+   Complete the task.
+   - Example: `textcraft finish "Successfully crafted all required items"`
+   - The task is graded when you finish, on what your inventory gained; no command is accepted after it, and a
+     task that never finishes counts as failed.
+
+The game keeps its state in `/app/textcraft`; change it only through the `textcraft` command.

tasks/textcraft-synth-train-easy-00629/solution/solve.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# The reference solution of textcraft-synth-train-easy-00629: the source task's gold trajectory (1 crafts), then finish.
+set -euo pipefail
+if ! command -v textcraft >/dev/null 2>&1; then
+  # platoon's process provider runs no image, so there is no textcraft command: run the game file itself.
+  textcraft() { python3 -I "${PLATOON_SANDBOX_ROOT:-}/app/textcraft/textcraft_game.py" "$@"; }
+fi
+textcraft craft t4_i2 2 raw_t8=1 raw_t9=1
+textcraft finish 'Crafted 1x t4_i2'

tasks/textcraft-synth-train-easy-00629/task.toml

@@ -0,0 +1,33 @@
+schema_version = "1.4"
+# The game's action log: a separate verifier receives it at the same path.
+artifacts = ["/app/textcraft/actions.jsonl"]
+
+[task]
+name = "textcraft-synth/train-easy-00629"
+description = "TextCraft-Synth: craft the following items: 1x t4_i2 (easy, crafting depth 2)"
+keywords = ["textcraft", "textcraft-synth", "crafting", "planning"]
+
+[metadata]
+environment = "textcraft-synth@1"
+split = "train"
+difficulty = "easy"
+max_depth = 2
+num_craft_steps = 1
+goal = "Craft the following items: 1x t4_i2"
+source_task_id = "textcraft_synth.train.629"
+env_task_id = "train:629"
+env_split_task_id = "train-easy:132"
+
+[verifier]
+environment_mode = "separate"
+timeout_sec = 180.0
+
+[agent]
+timeout_sec = 660.0
+
+[environment]
+network_mode = "no-network"
+cpus = 1
+memory_mb = 2048
+gpus = 0
+build_timeout_sec = 900.0

tasks/textcraft-synth-train-easy-00629/tests/Dockerfile

@@ -0,0 +1,13 @@
+# textcraft-synth-train-easy-00629: task.json sha256:a51761f978e9574b759b363fd1785a214f18d812d2166346dc6eef34d9673df5
+FROM docker.io/library/python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1
+# The same image as the task's environment, so one image serves the agent and the verifier.
+RUN set -eux; \
+    printf '#!/bin/sh\nexec python3 -I /app/textcraft/textcraft_game.py "$@"\n' \
+        > /usr/local/bin/textcraft; \
+    chmod 0755 /usr/local/bin/textcraft; \
+    apt-get -o APT::Sandbox::User=root update; \
+    apt-get -o APT::Sandbox::User=root install -y --no-install-recommends tmux; \
+    rm -rf /var/lib/apt/lists/*
+# The verifier's trusted copies of the grader, the game, the recipes and the task.
+WORKDIR /app
+COPY test.sh textcraft_game.py recipes.json task.json /tests/

tasks/textcraft-synth-train-easy-00629/tests/task.json

@@ -0,0 +1,15 @@
+{
+ "format": "textcraft-task/1",
+ "name": "textcraft-synth-train-easy-00629",
+ "world": "textcraft-synth",
+ "goal": "Craft the following items: 1x t4_i2",
+ "target_items": {
+  "t4_i2": 1
+ },
+ "initial_inventory": {
+  "raw_t8": 1,
+  "raw_t9": 2,
+  "raw_t2": 2
+ },
+ "recipes_sha256": "a020eec273337c66b35c0fc487664e35c44da65ad18e9afffe6a4c25af949f10"
+}

tasks/textcraft-synth-train-easy-00629/tests/test.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# Grade a TextCraft episode: replay the agent's action log (/app/textcraft/actions.jsonl) from the task's starting
+# inventory with the game's rules, using this directory's own copies of the game, the recipes and the task.  The
+# reward is 1 only when the log is an episode the rules allow that ends in `textcraft finish` with every target
+# crafted (the verdict goes to textcraft-verdict.json).  It runs in the agent's container (a shared verifier) or in a
+# separate verifier that received the log as an artifact.
+# PLATOON_SANDBOX_ROOT: platoon's process provider runs this on the host, with the sandbox's files below that
+# directory; sandboxes leave it unset.
+set -u
+root="${PLATOON_SANDBOX_ROOT:-}"
+tests="$root/tests"
+out="$root/logs/verifier"
+mkdir -p "$out"
+# A fresh verdict: nothing the agent may have left in the verifier's directory counts.
+rm -rf -- "$out/reward.json" "$out/reward.txt" "$out/textcraft-verdict.json"
+exec python3 -I "$tests/textcraft_game.py" verify --task "$tests/task.json" --recipes "$tests/recipes.json" \
+  --root "$root/" --log app/textcraft/actions.jsonl --out "$out"