techtree 0.1.0__py3-none-any.whl

techtree/resources/catalog/data-policies/hello-world-climb.json

@@ -0,0 +1 @@
+{"candidate_skill":{"ownership":"participant","public_release":"required_for_climb","training_use":"prohibited"},"derived_artifacts":{"aggregate_scores":"public","anonymized_product_analytics":"allowed","redacted_trace_projection":"public","uplift_report":"public"},"id":"policy_7c67a4c051e4891ccf9d8ec27ea5e357","owner":{"account_ref":null,"kind":"participant"},"raw_episodes":{"local_retention":"allowed","public_release":"prohibited","reproduction_access":"consent_required","server_upload":"prohibited","training_use":"prohibited"},"revocation":{"future_use_revocable":true,"immutable_published_proofs_remain":true},"schema_version":"techtree.data-policy.v1alpha1","version":1}

techtree/resources/catalog/taskset-validations/hello-world-climb.json

@@ -0,0 +1 @@
+{"checks":[{"detail":"all 36 tasks passed this check","id":"upstream_gold","status":"passed"},{"detail":"all 36 tasks passed this check","id":"upstream_setup","status":"passed"},{"detail":"two independent inspections agreed on all 36 task hashes, in order","id":"membership_repeatability","status":"passed"},{"detail":"all 36 task hashes are distinct","id":"task_hash_uniqueness","status":"passed"},{"detail":"all 36 task hashes match in order","id":"committed_membership_match","status":"passed"},{"detail":"36 tasks, as the selection asks for","id":"expected_task_count","status":"passed"}],"engine_digest":"sha256:29b1bbb8327d8f1a9ade03ff4504695ad3783ae34aaaa559e5c6bf9fc95e879b","method":{"kind":"verifiers_validate","mode":"all","runtime":"subprocess","validator_revision":"b2e4e8157783b2c0dffc7821044c87f29f1c3ccf"},"normalized_evidence":{"digest":"sha256:991be5e42acbd48c6bd9aaf8e1f5a5a2478c0a0e4bf04ad4f2be84b702adee43","media_type":"application/json","relative_path":null,"size":6889},"schema_version":"techtree.taskset-validation.v1alpha1","status":"valid","taskset_lock_digest":"sha256:8bed6f7c7f8b1a703020db9fa0fe08b29e68df6abd0e8f06ffa229722c7d87e0","upstream_summary":{"error":0,"invalid":0,"missing":0,"mode":"all","recorded":36,"timeout":0,"total":36,"valid":36,"valid_rate":1}}

techtree/resources/catalog/validation-evidence/hello-world-climb.json

@@ -0,0 +1 @@
+{"method":{"kind":"verifiers_validate","mode":"all","runtime":"subprocess","validator_revision":"b2e4e8157783b2c0dffc7821044c87f29f1c3ccf"},"schema_version":"techtree.validation-evidence.v1alpha1","summary":{"error":0,"invalid":0,"missing":0,"timeout":0,"total":36,"valid":36},"tasks":[{"gold":{"reason":"valid","valid":true},"position":0,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:af8a43bbaf38d332131d73ef9a5b995d9f330fdc37a777a12bef7c51c9fa0ed1"},{"gold":{"reason":"valid","valid":true},"position":1,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:e9a51458548dcfb10572fd9f032f00abdb298425114f68acdc074faa79229232"},{"gold":{"reason":"valid","valid":true},"position":2,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:bafa30550e9c0b09281b3b4b99cb467b9522babc9c2b9d97fee93abef26933b0"},{"gold":{"reason":"valid","valid":true},"position":3,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:1e74b2f5d62a6b25288d1d8ea3f85b6a0daf4a7697fe36d3f54b8534bb67b40d"},{"gold":{"reason":"valid","valid":true},"position":4,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:c05fd9db26808494349e9292ecde51a2c6b19e6d87e6f7d7080e2089829504f5"},{"gold":{"reason":"valid","valid":true},"position":5,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:02725a29cc06f2c883ad17e11a7fc2a09bd2b214df08f3c5c79e4941b54e315e"},{"gold":{"reason":"valid","valid":true},"position":6,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:206eb5646df5b41b67d28f0e42d370ceb3eb0d72a78cea97e5bbecb7e3841a9f"},{"gold":{"reason":"valid","valid":true},"position":7,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:c600be21a92a8c5401eaf645b8591b09f34052afe2ab61898d3be2edf8027cad"},{"gold":{"reason":"valid","valid":true},"position":8,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:b11c2add8339b16dbe85804f9b046e203a0b05db2b7fe9412a4dc45172c6555b"},{"gold":{"reason":"valid","valid":true},"position":9,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:bd835a69bbeb90d2b1c529aef6bac0c47a8b83750967bf4b64373a90540a07a4"},{"gold":{"reason":"valid","valid":true},"position":10,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:0a5bde37b05e74be39c62f4418d4812a123d627bc627591fb02dde124b246426"},{"gold":{"reason":"valid","valid":true},"position":11,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:f15ce47698160cd33fe7a0eb5e40a4cc7977624dd2bdf481ffee69b6204f26b3"},{"gold":{"reason":"valid","valid":true},"position":12,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:4fb4ddcab900a74eb7cb6ff6a730cc07b5a244535f40f6ddb6aa726cb2796596"},{"gold":{"reason":"valid","valid":true},"position":13,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:84d83849562386b699e048a91c5671e0f55b49098c9dfac9711a0895766caef3"},{"gold":{"reason":"valid","valid":true},"position":14,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:e08bb7c7a18a57a83d2ad8dba412c416a8746f708f54b8a29efc0355cabbdb45"},{"gold":{"reason":"valid","valid":true},"position":15,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:775f95710c5b09fd79e5720554b764f8a1c938063e5743977efe9a4f9d6dc12b"},{"gold":{"reason":"valid","valid":true},"position":16,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:832e70ff2ab29bfc83da704344417f0c9be2af2935247178ecd1cedc00477097"},{"gold":{"reason":"valid","valid":true},"position":17,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:5ef9194a49f5ada8a059b52cee70090a53df2bd5b415bf9ed8533287f3020dfc"},{"gold":{"reason":"valid","valid":true},"position":18,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:b195109ade431bf058e12c4ae1dff6c7bf05d4770be9af9ed27d8f588e95c910"},{"gold":{"reason":"valid","valid":true},"position":19,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:67eae183c9a688ab5172104c8f8e6380a3c052d367e5bd05964618f5f575bcd8"},{"gold":{"reason":"valid","valid":true},"position":20,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:cb5651849ccdc4309b9931918392831a2afc7d1b82e6a976a8777a23e73057aa"},{"gold":{"reason":"valid","valid":true},"position":21,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:391c080f51aa41130367d01e43ff21f80ef915274dd19b2f1a4aaf76380f8f13"},{"gold":{"reason":"valid","valid":true},"position":22,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:6c39dc6c8c62d0b471e3e40cc560d6cf105632c62e40de8ab21f00e1f3dcd8dc"},{"gold":{"reason":"valid","valid":true},"position":23,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:f5d73f388d604fc4df9afe63c70ca81f22646faad2bae99e24b1be0b5b6e239a"},{"gold":{"reason":"valid","valid":true},"position":24,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:c6bb62c1b970b25d39823748dd9cb087884cfb7360668f8c405d870af26e223e"},{"gold":{"reason":"valid","valid":true},"position":25,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:23c6f7a31ede5aa224788e4408ae1462ca57c559175232d740de6a139b02a5b4"},{"gold":{"reason":"valid","valid":true},"position":26,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:13fe52ddfdeab29466e3ed21db540a08d169e09d338e86852f96387f2272795d"},{"gold":{"reason":"valid","valid":true},"position":27,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:702eb0abb56d4554d7e9b8d75f15cf3d7ecfc0c8c9f83cf1c6c3caa25c5865f5"},{"gold":{"reason":"valid","valid":true},"position":28,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:aee7f9a4999dce081dbd0ce6ab65db37ffe9bb88d9b4a07b944f376fef0a14ad"},{"gold":{"reason":"valid","valid":true},"position":29,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:4b6a3d718933e312c05adff201cd14ab1d58b0eb5c0a0d32faccedc09cb9af68"},{"gold":{"reason":"valid","valid":true},"position":30,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:8b5ae57c98f3963e91dd611d4cfc37da07c80d4b3c0091ed7b4a76175376381a"},{"gold":{"reason":"valid","valid":true},"position":31,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:98f86f8d3663dcf3d0f32b6b1f9ef44913bb144355ecbcd89b8e4c96337b6964"},{"gold":{"reason":"valid","valid":true},"position":32,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:3efcd8d42d8adfce2038f5e5d8c88c3ec1d30d6ae3379c4727ea711b28e1929d"},{"gold":{"reason":"valid","valid":true},"position":33,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:bd2815069c78bced9ef23d36770c941b27753dad15db3e6c3a90c197181202a1"},{"gold":{"reason":"valid","valid":true},"position":34,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:08c8263a76b1d93beb586c8c39f0469721455cd08d517b15bcf827cf09ac0755"},{"gold":{"reason":"valid","valid":true},"position":35,"setup":{"reason":"valid","valid":true},"task_hash":"sha256:0777a89a3da39284a1765937c3ce1cea7af2ac27a98ffee32e86a2a1fccca9b5"}],"taskset_lock_digest":"sha256:8bed6f7c7f8b1a703020db9fa0fe08b29e68df6abd0e8f06ffa229722c7d87e0"}

techtree/resources/engines/default/engine.json

@@ -0,0 +1,20 @@
+{
+  "name": "default",
+  "packages": [
+    {
+      "name": "procedure-transfer-v1",
+      "source_digest": "sha256:f42a0d5e968478af40c703645d247ef043f115f6801d3b497eca5fab47261a7c",
+      "version": "0.1.0"
+    }
+  ],
+  "python_version": "3.12",
+  "schema_version": "techtree.engine.v1alpha1",
+  "supported_hosts": [
+    "darwin/amd64",
+    "darwin/arm64",
+    "linux/amd64",
+    "linux/arm64"
+  ],
+  "verifiers_revision": "b2e4e8157783b2c0dffc7821044c87f29f1c3ccf",
+  "verifiers_version": "0.3.1"
+}

techtree/resources/engines/default/packages/procedure-transfer-v1/procedure_transfer_v1/__init__.py

@@ -0,0 +1,7 @@
+from procedure_transfer_v1.env import ProcedureTransferEnv
+from procedure_transfer_v1.taskset import ProcedureTransferTaskset
+
+__all__ = [
+    "ProcedureTransferEnv",
+    "ProcedureTransferTaskset",
+]

techtree/resources/engines/default/packages/procedure-transfer-v1/procedure_transfer_v1/algorithm.py

@@ -0,0 +1,136 @@
+"""BranchCode v1: the deterministic procedure the reference taskset scores.
+
+The procedure is specified in section 22.2 of the Climb v0.1 WP0-WP5
+specification:
+
+1. Normalize the input to lowercase ASCII.
+2. Reject empty or unsupported text.
+3. Map ``a=1`` through ``z=26``.
+4. Multiply each letter value by its one-indexed position.
+5. Sum the products.
+6. Count the distinct characters.
+7. Add seven times the distinct count.
+8. Reduce modulo 97.
+9. Format as ``BRANCH-XX``.
+
+Every function here is pure and deterministic: no environment access, no
+randomness, no clocks, no network, no I/O.
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "ALPHABET",
+    "DISTINCT_WEIGHT",
+    "MODULUS",
+    "branch_code",
+    "branch_code_number",
+    "normalize_input",
+]
+
+ALPHABET = "abcdefghijklmnopqrstuvwxyz"
+"""The only characters BranchCode v1 accepts after normalization."""
+
+DISTINCT_WEIGHT = 7
+"""Multiplier applied to the distinct-character count (step 7)."""
+
+MODULUS = 97
+"""Modulus applied to the weighted sum (step 8)."""
+
+_LETTER_VALUES = {letter: index for index, letter in enumerate(ALPHABET, start=1)}
+
+
+def normalize_input(value: str) -> str:
+    """Strip, lowercase, and require ASCII ``a``-``z``.
+
+    Surrounding whitespace is removed and the remaining text is lowercased.
+    The result must be non-empty and contain only the twenty-six ASCII
+    lowercase letters; anything else is unsupported input.
+
+    >>> normalize_input("  Maple ")
+    'maple'
+
+    Args:
+        value: Raw candidate input.
+
+    Returns:
+        The normalized lowercase ASCII form of ``value``.
+
+    Raises:
+        TypeError: If ``value`` is not a string.
+        ValueError: If the normalized text is empty or holds any character
+            outside ``a``-``z``.
+    """
+    if not isinstance(value, str):
+        raise TypeError(
+            f"BranchCode input must be a string, got {type(value).__name__}"
+        )
+
+    normalized = value.strip().lower()
+    if not normalized:
+        raise ValueError(
+            "BranchCode input must not be empty after stripping whitespace"
+        )
+
+    unsupported = sorted(
+        {character for character in normalized if character not in _LETTER_VALUES}
+    )
+    if unsupported:
+        rendered = ", ".join(repr(character) for character in unsupported)
+        raise ValueError(
+            f"BranchCode input must be ASCII a-z only; "
+            f"unsupported characters: {rendered}"
+        )
+
+    return normalized
+
+
+def branch_code_number(value: str) -> int:
+    """Return the BranchCode v1 number in ``0..96``.
+
+    >>> branch_code_number("maple")
+    74
+
+    Args:
+        value: Raw candidate input; normalized before scoring.
+
+    Returns:
+        The weighted positional sum plus seven times the distinct-character
+        count, reduced modulo 97.
+
+    Raises:
+        TypeError: If ``value`` is not a string.
+        ValueError: If ``value`` is empty or not ASCII ``a``-``z``.
+    """
+    normalized = normalize_input(value)
+
+    weighted_sum = sum(
+        _LETTER_VALUES[character] * position
+        for position, character in enumerate(normalized, start=1)
+    )
+    distinct_count = len(set(normalized))
+
+    return (weighted_sum + DISTINCT_WEIGHT * distinct_count) % MODULUS
+
+
+def branch_code(value: str) -> str:
+    """Return the ``BRANCH-XX`` token for ``value``.
+
+    The numeric part is always two digits, zero-padded.
+
+    >>> branch_code("birch")
+    'BRANCH-64'
+    >>> branch_code("acorn")
+    'BRANCH-35'
+
+    Args:
+        value: Raw candidate input; normalized before scoring.
+
+    Returns:
+        The formatted ``BRANCH-XX`` token.
+
+    Raises:
+        TypeError: If ``value`` is not a string.
+        ValueError: If ``value`` is empty or not ASCII ``a``-``z``.
+    """
+    return f"BRANCH-{branch_code_number(value):02d}"

techtree/resources/engines/default/packages/procedure-transfer-v1/procedure_transfer_v1/dataset.py

@@ -0,0 +1,156 @@
+"""The frozen proving dataset for the BranchCode v1 reference taskset.
+
+``PROVING_INPUTS`` is a literal, hand-written tuple. It is never generated,
+sampled, shuffled, or extended at runtime: the ordered membership of this
+tuple is what the Campaign membership commitment pins, so any change to the
+contents *or* the order is a breaking change to every existing commitment.
+
+Ordering rule (stable and auditable): by length ascending, then
+alphabetically within each length.
+
+Composition rule, and the reason the tuple looks the way it does: exactly
+twenty-four of the thirty-six inputs use each character only once, and the
+other twelve repeat at least one. That split is load-bearing. Step 7 adds
+seven times the *distinct*-character count, so an input whose characters are
+all different is the one case where counting characters the naive way — every
+character, repeats included — still lands on the right answer. The
+introductory Climb's starter Skill counts the naive way on purpose, and the
+twenty-four-to-twelve split is what puts its score in the calibrated band with
+headroom left to improve. Decisions document 0012 fixes the split; changing
+which inputs are here moves it, so the count is checked by the repository's
+own tests rather than left to whoever edits next.
+
+None of these strings ever appears in a documentation example, a docstring,
+or a candidate skill; the worked examples are reserved separately in
+``DOCUMENTATION_EXAMPLES`` so the proving inputs stay unseen.
+"""
+
+from __future__ import annotations
+
+from procedure_transfer_v1.algorithm import normalize_input
+
+__all__ = [
+    "DOCUMENTATION_EXAMPLES",
+    "MAX_INPUT_LENGTH",
+    "MIN_INPUT_LENGTH",
+    "MIN_PROVING_INPUTS",
+    "PROVING_INPUTS",
+    "proving_inputs",
+    "validate_dataset",
+]
+
+MIN_PROVING_INPUTS = 32
+"""Specification floor on the size of the frozen dataset."""
+
+MIN_INPUT_LENGTH = 4
+"""Shortest permitted proving input."""
+
+MAX_INPUT_LENGTH = 12
+"""Longest permitted proving input."""
+
+DOCUMENTATION_EXAMPLES = frozenset({"acorn", "birch", "maple"})
+"""Worked-example inputs reserved for documentation and never proven against."""
+
+PROVING_INPUTS: tuple[str, ...] = (
+    # length 5
+    "alder",
+    "aspen",
+    "carob",
+    "cedar",
+    "hazel",
+    "larch",
+    "rowan",
+    # length 6
+    "almond",
+    "cashew",
+    "spruce",
+    "willow",
+    # length 7
+    "apricot",
+    "dogwood",
+    "hemlock",
+    "juniper",
+    "sequoia",
+    # length 8
+    "blackgum",
+    "hazelnut",
+    "hornbeam",
+    "ironwood",
+    "mangrove",
+    "mulberry",
+    "sycamore",
+    "tamarack",
+    # length 9
+    "buckthorn",
+    "jacaranda",
+    "jackfruit",
+    "mockernut",
+    "sassafras",
+    "waxmyrtle",
+    # length 10
+    "blackthorn",
+    "cottonwood",
+    "elderberry",
+    "eucalyptus",
+    "sandalwood",
+    # length 11
+    "bristlecone",
+)
+"""The frozen, ordered proving inputs. Do not reorder, add, or remove."""
+
+
+def proving_inputs() -> tuple[str, ...]:
+    """Return the immutable, ordered proving inputs.
+
+    Returns:
+        ``PROVING_INPUTS`` itself; tuples are immutable, so callers cannot
+        disturb the committed order.
+    """
+    return PROVING_INPUTS
+
+
+def validate_dataset() -> None:
+    """Check every invariant the frozen dataset must satisfy.
+
+    Verifies the dataset size floor, uniqueness, the ASCII ``a``-``z``
+    charset, the length bounds, the length-then-alphabetical order, and that
+    no proving input collides with a reserved documentation example.
+
+    Raises:
+        ValueError: On the first invariant that fails.
+    """
+    count = len(PROVING_INPUTS)
+    if count < MIN_PROVING_INPUTS:
+        raise ValueError(
+            f"PROVING_INPUTS must hold at least {MIN_PROVING_INPUTS} entries, "
+            f"found {count}"
+        )
+
+    seen: set[str] = set()
+    for entry in PROVING_INPUTS:
+        if entry in seen:
+            raise ValueError(f"PROVING_INPUTS contains a duplicate entry: {entry!r}")
+        seen.add(entry)
+
+        if normalize_input(entry) != entry:
+            raise ValueError(
+                "PROVING_INPUTS entry must already be normalized lowercase a-z: "
+                f"{entry!r}"
+            )
+
+        if not MIN_INPUT_LENGTH <= len(entry) <= MAX_INPUT_LENGTH:
+            raise ValueError(
+                f"PROVING_INPUTS entry must be {MIN_INPUT_LENGTH}-{MAX_INPUT_LENGTH} "
+                f"characters, found {len(entry)}: {entry!r}"
+            )
+
+        if entry in DOCUMENTATION_EXAMPLES:
+            raise ValueError(
+                f"PROVING_INPUTS entry overlaps a documentation example: {entry!r}"
+            )
+
+    ordered = tuple(sorted(PROVING_INPUTS, key=lambda entry: (len(entry), entry)))
+    if ordered != PROVING_INPUTS:
+        raise ValueError(
+            "PROVING_INPUTS must be ordered by length ascending, then alphabetically"
+        )

techtree/resources/engines/default/packages/procedure-transfer-v1/procedure_transfer_v1/env.py

@@ -0,0 +1,48 @@
+"""The environment that gives the evaluated role its real name. Spec 6.5.
+
+Verifiers' default ``SingleAgentEnv`` seats its one agent in a field called
+``agent``, and the field name is what every trace records as ``agent.name``.
+Techtree's scientific model calls the evaluated role ``subject``, and receipts
+group traces by declared role, so the choice is between renaming a recorded
+role afterwards for presentation and making the role real where it is
+recorded. Renaming after the fact would mean a receipt describing something the
+raw evidence never said. This environment makes it real instead: the seat is a
+field named ``subject``, so every trace this package produces records
+``agent.name == "subject"`` and no trace anywhere records ``agent``.
+
+That the package can export a Taskset and an Env together is not a trick.
+Verifiers resolves plugins by requested base type, so the taskset loader sees
+exactly one Taskset and the environment loader sees exactly one Env. The
+behaviour was proven against the pinned commit before this file was written;
+``docs/verifiers-eval.md`` records it.
+
+The environment does one thing and holds no policy. Everything about how the
+subject is configured — model, harness, runtime, skills — arrives through the
+compiled configuration, because a knob here would be a second place an
+experiment could differ.
+"""
+
+from __future__ import annotations
+
+import verifiers.v1 as vf
+
+__all__ = ["ProcedureTransferEnv", "ProcedureTransferEnvConfig"]
+
+
+class ProcedureTransferEnvConfig(vf.EnvConfig):
+    """The one seat, named for the role it plays."""
+
+    subject: vf.AgentConfig = vf.AgentConfig()
+
+
+class ProcedureTransferEnv(vf.Env[ProcedureTransferEnvConfig]):
+    """One episode is the subject attempting one task."""
+
+    async def run(self, task: vf.Task, agents: vf.Agents) -> None:
+        """Play one task through the subject seat.
+
+        Args:
+            task: The task this episode is seeded from.
+            agents: The episode's agents, addressed by seat name.
+        """
+        await agents.subject.run(task)

techtree/resources/engines/default/packages/procedure-transfer-v1/procedure_transfer_v1/taskset.py

@@ -0,0 +1,163 @@
+"""The Verifiers Taskset that scores BranchCode v1 procedure transfer.
+
+Spec section 22.5. Shapes here were proven against the pinned Verifiers commit
+`b2e4e8157783b2c0dffc7821044c87f29f1c3ccf` by the PI0 preflight; see
+`docs/verifiers-pin-0.3.1.md`.
+
+The prompt deliberately carries the *name* of the procedure and the *shape* of
+the expected answer, and nothing else. BranchCode v1 itself — letter values,
+positional weighting, the distinct-character term, the modulus — never appears
+here. A subject that has not been given the procedure cannot recover it from
+the prompt; that gap is exactly what the reference taskset measures.
+
+This module is the only part of the package that imports Verifiers. It runs
+inside the managed engine environment, never inside the ordinary Techtree
+environment.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+import verifiers.v1 as vf
+
+from procedure_transfer_v1.algorithm import (
+    MODULUS,
+    branch_code,
+    branch_code_number,
+)
+from procedure_transfer_v1.dataset import proving_inputs, validate_dataset
+
+__all__ = [
+    "PROMPT_TEMPLATE",
+    "TASK_NAME_TEMPLATE",
+    "ProcedureTransferData",
+    "ProcedureTransferTask",
+    "ProcedureTransferTaskset",
+]
+
+PROMPT_TEMPLATE = (
+    "Apply BranchCode v1 to this input:\n"
+    "\n"
+    "{input_text}\n"
+    "\n"
+    "Return only the final BRANCH-XX token."
+)
+"""Spec section 22.5, verbatim. Never add procedure detail to this string."""
+
+TASK_NAME_TEMPLATE = "branch-code-{index:03d}"
+"""Stable task names, one per proving input, in dataset order."""
+
+
+def normalize_reply(reply: str) -> str:
+    """Return the comparable form of a subject reply.
+
+    A reply is trimmed and upper-cased before it is compared with the hidden
+    answer. Nothing is extracted from surrounding prose: the prompt asks for
+    the token alone, so a reply that buries the token in a sentence is wrong.
+
+    Args:
+        reply: Raw subject reply text.
+
+    Returns:
+        The trimmed, upper-cased reply.
+    """
+    return reply.strip().upper()
+
+
+class ProcedureTransferData(vf.TaskData):
+    """Wire data for one BranchCode task.
+
+    ``answer`` is the oracle result. It is part of the task's content hash and
+    is never placed in the prompt.
+    """
+
+    input_text: str
+    answer: str
+
+
+class ProcedureTransferTask(vf.Task[ProcedureTransferData]):
+    """One proving input, scored by exact match against the hidden answer."""
+
+    def score_reply(self, reply: str) -> float:
+        """Return 1.0 for an exact match with the hidden answer, else 0.0.
+
+        Args:
+            reply: Raw subject reply text.
+
+        Returns:
+            ``1.0`` or ``0.0``.
+        """
+        return 1.0 if normalize_reply(reply) == self.data.answer else 0.0
+
+    @vf.reward
+    async def exact_match(self, trace: vf.Trace) -> float:
+        """Score the last assistant reply in ``trace``.
+
+        Args:
+            trace: The rollout trace under evaluation.
+
+        Returns:
+            ``1.0`` or ``0.0``.
+        """
+        return self.score_reply(trace.last_reply)
+
+    async def validate(self, runtime: vf.Runtime) -> bool:
+        """Prove this task is well formed without consulting a model.
+
+        Four independent conditions, all required:
+
+        1. The oracle recomputed from ``input_text`` equals the stored answer.
+        2. A stored answer exists at all.
+        3. The correct answer scores 1.0.
+        4. A well-formed but wrong token scores 0.0.
+
+        Condition 4 uses the next code in the modular sequence rather than a
+        malformed placeholder, so the negative control is a genuine near miss
+        that only exact matching rejects.
+
+        Args:
+            runtime: The Verifiers runtime; unused, this check is model-free.
+
+        Returns:
+            True when every condition holds.
+        """
+        del runtime
+
+        oracle = branch_code(self.data.input_text)
+        near_miss_number = (branch_code_number(self.data.input_text) + 1) % MODULUS
+        near_miss = f"BRANCH-{near_miss_number:02d}"
+
+        return (
+            bool(self.data.answer)
+            and oracle == self.data.answer
+            and self.score_reply(self.data.answer) == 1.0
+            and self.score_reply(near_miss) == 0.0
+        )
+
+
+class ProcedureTransferTaskset(vf.Taskset[ProcedureTransferTask, vf.TasksetConfig]):
+    """The frozen proving inputs, one deterministic task each, in dataset order."""
+
+    def load(self) -> Iterable[ProcedureTransferTask]:
+        """Yield one task per proving input.
+
+        Yield order is the frozen dataset order, which is what the Campaign
+        membership commitment pins.
+
+        Yields:
+            One :class:`ProcedureTransferTask` per proving input.
+        """
+        validate_dataset()
+
+        for index, input_text in enumerate(proving_inputs()):
+            yield ProcedureTransferTask(
+                ProcedureTransferData(
+                    idx=index,
+                    name=TASK_NAME_TEMPLATE.format(index=index),
+                    prompt=PROMPT_TEMPLATE.format(input_text=input_text),
+                    input_text=input_text,
+                    answer=branch_code(input_text),
+                ),
+                self.config.task,
+            )

techtree/resources/engines/default/packages/procedure-transfer-v1/pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "procedure-transfer-v1"
+version = "0.1.0"
+description = "Deterministic BranchCode procedure-transfer taskset"
+requires-python = ">=3.12"
+dependencies = []
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["procedure_transfer_v1"]

techtree/resources/engines/default/pyproject.toml

@@ -0,0 +1,23 @@
+# The managed Techtree evaluation engine.
+#
+# Generated by tools/build_engine_bundle.py. Do not edit by hand: the file is
+# part of the engine bundle digest, and `make generated-check` rewrites it in a
+# throwaway tree and fails on any difference.
+
+[project]
+name = "techtree-engine-default"
+version = "0.1.0"
+description = "Pinned Verifiers environment and reference tasksets for Techtree."
+requires-python = ">=3.12,<3.13"
+dependencies = [
+  "procedure-transfer-v1",
+  "verifiers",
+]
+
+[tool.uv]
+# The engine project is an environment, not a distribution. Nothing installs it.
+package = false
+
+[tool.uv.sources]
+procedure-transfer-v1 = { path = "packages/procedure-transfer-v1", editable = true }
+verifiers = { git = "https://github.com/PrimeIntellect-ai/verifiers", rev = "b2e4e8157783b2c0dffc7821044c87f29f1c3ccf" }