MiMo-V2.6-RL Terminal as Harbor tasks

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

LICENSE-mimoagent.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Xiaomi Corporation
+Copyright (c) 2025 Kilian A. Lieret and Carlos E. Jimenez (mini-swe-agent)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

NOTICE

@@ -0,0 +1,31 @@
+MiMo-V2.6-RL in Harbor format
+Converted by Hugging Face and the FineEnvs team. Not affiliated with or endorsed by Xiaomi.
+
+This work is derived from, and redistributes material of:
+
+  MiMo-V2.6-RL-oss (https://huggingface.co/datasets/XiaomiMiMo/MiMo-V2.6-RL-oss, revision 639865fd3374018d6cb29b9fb82dd531406fcf5f)
+  Copyright Xiaomi Corporation. Licensed under the Apache License, Version 2.0 (LICENSE).
+  The task prompts, test patches, test commands, Terminal-Bench test files, General-domain verifier files,
+  and the Docker images referenced by digest (docker.io/xiaomimimo/mimo-v2.6-rl-oss) are Xiaomi's.
+
+  XiaomiMiMo/verl (https://github.com/XiaomiMiMo/verl, commit a2ad9f6), Apache License 2.0 (LICENSE):
+  tests/music_scorer/ (recipes/design/music/scorer), tests/webdev/shot.py, tests/webdev/eval_rubric.py,
+  tests/webdev/verdict.py (parse_verdict from eval_mode.py), the Webdev agent prompt, and the step limits.
+
+  XiaomiMiMo/mimoagent (https://github.com/XiaomiMiMo/mimoagent, commit 467f0a1), MIT License
+  (LICENSE-mimoagent.md; Copyright (c) 2026 Xiaomi Corporation, Copyright (c) 2025 Kilian A. Lieret and
+  Carlos E. Jimenez (mini-swe-agent)): tests/server_arvo.py, and the Code-domain residue scrub, cache scrub,
+  git-clean keep list, test-file reset and ARVO description parsing, ported into the setup and test scripts.
+
+Vendored files are unmodified. Changes made in this conversion (Apache-2.0 section 4(b)):
+  - Each environment is repackaged as a Harbor task: task.toml, instruction.md, environment/, tests/.
+  - Setup that Xiaomi's harness runs before the agent is written as environment/setup/setup.sh and run from
+    the task's healthcheck. In the Code residue scrub, /logs is emptied rather than deleted (Harbor owns it).
+  - Grading entry points (tests/test.sh, grade.py, verify.py) wrap the original graders. Cyber re-runs the
+    last submitted PoC with server_arvo.py's own logic; General redacts judge-key echoes from its output.
+  - Music: "Write your complete reply to /app/answer.md." is appended to each prompt, because a Harbor task
+    is an agent session rather than a single completion.
+  - Images are referenced by digest instead of by tag; the MCP sidecar pins mcp==1.26.0.
+  - agents/mimo_opencode.py extends Harbor's OpenCode agent (Apache-2.0, harbor-framework/harbor).
+
+Harbor (https://github.com/harbor-framework/harbor) is the task format and runner; it is not redistributed here.

README.md

@@ -0,0 +1,121 @@
+---
+license: apache-2.0
+language:
+- en
+- zh
+task_categories:
+- other
+tags:
+- rl-environment
+- reinforcement-learning
+- harbor
+- agent
+- mimo
+- mimo-v2.6-rl
+- terminal
+- terminal
+- terminal-bench
+- cli
+size_categories:
+- n<1K
+viewer: false
+---
+
+[![View tasks in Harbor Visualiser](https://img.shields.io/badge/%F0%9F%A4%97%20Harbor%20Visualiser-View%20tasks-FFD21F?style=for-the-badge)](https://huggingface.co/spaces/HuggingFaceH4/harbor-visualiser?dataset=FineEnvs/MiMo-V2.6-RL-harbor-terminal)
+[![MiMo RL Environment Explorer](https://img.shields.io/badge/%F0%9F%A4%97%20Explorer-Run%20a%20rollout-FFD21F?style=for-the-badge)](https://huggingface.co/spaces/FineEnvs/MiMo-RL-Envs-Explorer)
+
+# MiMo-V2.6-RL Terminal (Harbor)
+
+**Terminal-Bench style tasks.** 64 Harbor tasks from the Terminal domain of Xiaomi's
+[MiMo-V2.6-RL-oss](https://huggingface.co/datasets/XiaomiMiMo/MiMo-V2.6-RL-oss), the RL environments MiMo-V2.6 was trained
+on, converted so every one runs as a standard Harbor task.
+
+Self-contained command-line tasks in the Terminal-Bench format, graded by each task's own pytest suite and anti-hack guard.
+
+| | |
+|---|---|
+| Tasks | 64 |
+| Graded by | pytest + anti-hack guard (deterministic) |
+| Reference step limit | 500 |
+| Source | [`XiaomiMiMo/MiMo-V2.6-RL-oss`](https://huggingface.co/datasets/XiaomiMiMo/MiMo-V2.6-RL-oss) at `639865fd3374` |
+| Reference harness | XiaomiMiMo/verl `a2ad9f6` + XiaomiMiMo/mimoagent `467f0a1` |
+
+Part of a set of six: [code](https://huggingface.co/datasets/FineEnvs/MiMo-V2.6-RL-harbor-code), [cyber](https://huggingface.co/datasets/FineEnvs/MiMo-V2.6-RL-harbor-cyber), [general](https://huggingface.co/datasets/FineEnvs/MiMo-V2.6-RL-harbor-general), [terminal](https://huggingface.co/datasets/FineEnvs/MiMo-V2.6-RL-harbor-terminal), [webdev](https://huggingface.co/datasets/FineEnvs/MiMo-V2.6-RL-harbor-webdev), [music](https://huggingface.co/datasets/FineEnvs/MiMo-V2.6-RL-harbor-music).
+
+## Layout
+
+```text
+tasks/<task_id>/
+├── task.toml         # image pinned by digest, one-time setup (healthcheck), judge settings, provenance
+├── instruction.md    # the prompt the agent sees, word for word what Xiaomi's harness gives it
+├── environment/      # Dockerfile (FROM the same digest) and setup/, a readable copy of the setup
+└── tests/            # test.sh and everything grading needs; uploaded only after the agent finishes
+registry.json         # Harbor registry entry
+data/tasks.jsonl      # one metadata row per task, for filtering without walking the tree
+manifest.json         # sha256 of every task directory
+jobs/terminal.yaml      # the reference agent settings
+agents/mimo_opencode.py
+```
+
+Example: [task.toml](https://huggingface.co/datasets/FineEnvs/MiMo-V2.6-RL-harbor-terminal/blob/main/tasks/candidate-0036-software-data-engineering/task.toml) ·
+[instruction](https://huggingface.co/datasets/FineEnvs/MiMo-V2.6-RL-harbor-terminal/blob/main/tasks/candidate-0036-software-data-engineering/instruction.md) ·
+[verifier](https://huggingface.co/datasets/FineEnvs/MiMo-V2.6-RL-harbor-terminal/blob/main/tasks/candidate-0036-software-data-engineering/tests/test.sh).
+
+## Run
+
+```bash
+hf download FineEnvs/MiMo-V2.6-RL-harbor-terminal --repo-type dataset --local-dir mimo-terminal
+cd mimo-terminal
+PYTHONPATH=agents HF_TOKEN=hf_... harbor run -y -c jobs/terminal.yaml
+```
+
+The job runs `agents/mimo_opencode.py` (OpenCode 1.18.32) on HF Sandbox with the reference settings: the step
+limit above, replies of up to 65,536 tokens, thinking low, no web fetch or search.
+Change `model_name` and the provider block for another model. Any Harbor agent can run these tasks; this one
+also applies two steps of Xiaomi's harness a task file can't express: the answer-leak blocklist after install,
+and the unprivileged `agent` user on sandboxes that run everything as root.
+
+Serving them to a trainer works like any Harbor dataset, for example with OpenEnv:
+
+```bash
+openenv harbor serve --dataset FineEnvs/MiMo-V2.6-RL-harbor-terminal --llm-url http://127.0.0.1:8000/v1 --model <your-model>
+```
+
+## How it was converted
+
+With the [mimo_harbor adapter](https://github.com/adithya-s-k/FineEnvs/tree/mimo-explorer-rollouts/mimo-explorer/mimo_harbor). It reads the source at one pinned revision and every image through
+a digest lock, so a rerun produces byte-identical tasks (`manifest.json`). Setup and grading follow Xiaomi's
+harness step by step, as the explorer's runner does, using the same vendored graders:
+
+- Nothing that grades a task (hidden tests, rubrics, verifier scripts) is reachable while the agent works.
+- A testbed failure (a patch that won't apply, a system that died, a judge that never answered) writes no reward,
+  so Harbor records an error rather than a 0.
+- Images are pinned by digest; HF Sandbox and other prebuilt-image backends run them without a build step.
+
+Deviations from the reference, and why, are listed in the adapter's README.
+
+## Validation
+
+- All 7,780 tasks across the six datasets load with Harbor's task loader and pass the adapter's static checks
+  (digest-pinned images, setup payload equal to its readable copy, rubrics only under `tests/`).
+- With Harbor's no-op agent every dataset scores 0 and every verifier runs to completion: no free rewards.
+- One task per dataset was run end to end with GLM-5.3 both in Harbor and in the
+  [explorer](https://huggingface.co/spaces/FineEnvs/MiMo-RL-Envs-Explorer), which runs Xiaomi's harness; the results match (see the adapter's `parity.md`).
+  A full parity study over repeated runs has not been done yet.
+
+## Credits
+
+The environments, their prompts, tests, verifiers, images and graders are the work of the
+[Xiaomi MiMo](https://huggingface.co/XiaomiMiMo) team, released as
+[XiaomiMiMo/MiMo-V2.6-RL-oss](https://huggingface.co/datasets/XiaomiMiMo/MiMo-V2.6-RL-oss) together with their training code
+[XiaomiMiMo/verl](https://github.com/XiaomiMiMo/verl) and agent harness
+[XiaomiMiMo/mimoagent](https://github.com/XiaomiMiMo/mimoagent). mimoagent builds on
+[mini-swe-agent](https://github.com/SWE-agent/mini-swe-agent) (Kilian A. Lieret and Carlos E. Jimenez).
+The task format and runner are [Harbor](https://github.com/harbor-framework/harbor).
+This conversion is by Hugging Face and the FineEnvs team, and is not affiliated with or endorsed by Xiaomi.
+
+## License
+
+Apache-2.0, as the source dataset (`LICENSE`). Files vendored from XiaomiMiMo/mimoagent (`tests/server_arvo.py`
+in Cyber tasks, and the ported setup commands) are MIT (`LICENSE-mimoagent.md`). `NOTICE` lists every source,
+its license, and the changes this conversion made. Vendored grader files are unmodified.

agents/mimo_opencode.py

@@ -0,0 +1,71 @@
+"""OpenCode for MiMo tasks: Harbor's OpenCode agent plus two steps of Xiaomi's harness that a task can't express.
+
+1. The answer-leak blocklist. mimoagent appends it to /etc/hosts after the agent is installed (the install itself
+   needs github.com). Task setup leaves the list in /var/lib/mimo/blocklist; this agent applies it right after
+   install and fails closed, as mimoagent does.
+2. The unprivileged agent user. Cyber and General run the agent as `agent`, so the verify server and the systems'
+   data stay out of its reach. Tasks say so in [agent].user; on environments that cannot switch users (HF Sandbox
+   runs everything as root), this agent drops to that user itself with runuser.
+
+3. The output ceiling. OpenCode caps a reply at 32,000 tokens unless OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX says
+   otherwise; it is set here from the configured model limit (65,536, mimoagent's opencode.yaml) rather than in the
+   job's env, because Harbor treats any env var named *TOKEN* as a secret and blanks its value in every output.
+
+Use it with `import_path: mimo_opencode:MimoOpenCode` (see jobs/*.yaml).
+"""
+
+from __future__ import annotations
+
+import shlex
+from typing import Any
+
+from harbor.agents.installed.opencode import OpenCode
+from harbor.environments.base import BaseEnvironment
+
+MIMO = "/var/lib/mimo"
+
+
+class MimoOpenCode(OpenCode):
+    @staticmethod
+    def name() -> str:
+        return "mimo-opencode"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._drop_to: str | None | bool = False   # False: not checked yet
+        limits = [m.get("limit", {}).get("output") for p in (self._opencode_config.get("provider") or {}).values()
+                  for m in (p.get("models") or {}).values()]
+        top = max([x for x in limits if isinstance(x, int)] or [0])
+        self._mimo_env = {"OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX": str(top)} if top > 32000 else {}
+
+    async def _target_user(self, environment: BaseEnvironment) -> str | None:
+        """The user the task wants the agent to run as, if the environment would otherwise run it as root."""
+        if self._drop_to is False:
+            want = await environment.exec(f"cat {MIMO}/agent_user 2>/dev/null", user="root")
+            user = (want.stdout or "").strip() or None
+            if user:
+                who = await super().exec_as_agent(environment, "id -un")
+                user = user if (who.stdout or "").strip() == "root" else None
+            self._drop_to = user
+        return self._drop_to
+
+    async def exec_as_agent(self, environment: BaseEnvironment, command: str, env: dict[str, str] | None = None,
+                            cwd: str | None = None, timeout_sec: int | None = None) -> Any:
+        env = {**(env or {}), **self._mimo_env}
+        user = await self._target_user(environment)
+        if user:
+            home = f"/home/{user}"
+            exports = " ".join(f"{k}={shlex.quote(v)}" for k, v in (env or {}).items())
+            command = (f"runuser -u {user} -- env HOME={home} USER={user} {exports} "
+                       f"bash -c {shlex.quote(('cd ' + shlex.quote(cwd) + ' && ' if cwd else '') + command)}")
+        return await super().exec_as_agent(environment, command, env=env, cwd=cwd, timeout_sec=timeout_sec)
+
+    async def install(self, environment: BaseEnvironment) -> None:
+        await super().install(environment)
+        res = await environment.exec(
+            f"if [ -f {MIMO}/blocklist ]; then cat {MIMO}/blocklist >> /etc/hosts && grep -c '^0.0.0.0' /etc/hosts; "
+            f"else echo none; fi", user="root")
+        if res.return_code != 0:
+            raise RuntimeError("could not install the answer-leak blocklist in /etc/hosts: " + (res.stderr or res.stdout or "")[-300:])
+        out = (res.stdout or "").strip()
+        self.logger.info("answer-leak blocklist: " + ("none for this task" if out == "none" else f"{out} hosts blocked in /etc/hosts"))

jobs/terminal.yaml

@@ -0,0 +1,57 @@
+# MiMo-V2.6-RL terminal on Harbor with the reference agent settings.
+# From the repo root:  PYTHONPATH=agents HF_TOKEN=... harbor run -y -c jobs/terminal.yaml
+jobs_dir: jobs/terminal
+n_attempts: 1
+timeout_multiplier: 1.0
+orchestrator:
+  type: local
+  n_concurrent_trials: 4
+environment:
+  type: hf-sandbox
+  delete: true
+  kwargs:
+    flavor: cpu-basic
+    job_timeout: 1h
+agents:
+- import_path: mimo_opencode:MimoOpenCode
+  model_name: hf/zai-org/GLM-5.3:deepinfra
+  kwargs:
+    version: 1.18.32
+    opencode_config:
+      autoupdate: false
+      share: disabled
+      provider:
+        hf:
+          npm: '@ai-sdk/openai-compatible'
+          name: Hugging Face Inference Providers
+          options:
+            baseURL: https://router.huggingface.co/v1
+            apiKey: '{env:HF_TOKEN}'
+          models:
+            zai-org/GLM-5.3:deepinfra:
+              name: zai-org/GLM-5.3
+              tool_call: true
+              limit:
+                context: 1000000
+                output: 65536
+              options:
+                reasoningEffort: low
+      agent:
+        build:
+          steps: 500
+      snapshot: true
+      lsp: true
+      formatter: true
+      permission:
+        webfetch: deny
+        websearch: deny
+        bash: allow
+        edit: allow
+  env:
+    HF_TOKEN: ${HF_TOKEN}
+    OPENCODE_DISABLE_MODELS_FETCH: '1'
+    OPENCODE_DISABLE_AUTOUPDATE: '1'
+    OPENCODE_DISABLE_LSP_DOWNLOAD: '1'
+    OPENCODE_DISABLE_SHARE: '1'
+datasets:
+- path: tasks

manifest.json

@@ -0,0 +1,71 @@
+{
+ "adapter": "mimo_harbor 1.0.0",
+ "source": "XiaomiMiMo/MiMo-V2.6-RL-oss",
+ "revision": "639865fd3374018d6cb29b9fb82dd531406fcf5f",
+ "tasks": {
+  "candidate-0036-software-data-engineering": "734575adea9e066cc5f5272e8508fcd15287a94ca0a345d2a1c48c0def522ead",
+  "candidate-0109-science-robotics": "a18c070b6edace26565016d53182b5f12bfd10fe4a5efede88c0903e02d45e57",
+  "candidate-0260-security-appsec": "ea37839a405619b7b5ab7e32833f59739aeb5369c82487a61710d124a6c50e6c",
+  "candidate-0308-security-forensics": "7680476729cd10ca44d78ffae4040bac09734db2e2199de38869a9b62b0be4fc",
+  "candidate-0390-security-appsec": "ab400001b09a98c2a4e35e37405c604bec35453b9d0e6fe1395abd32816ccdce",
+  "candidate-0461-ml-evaluation": "722a6df4425e86b2a08b3e1403e81d0ad19a65ee090ac146d70a7d0a40566a32",
+  "candidate-0534-ml-training": "d09fabe989d05d86ab0b222f73fa832e4217a9d82173afdfe4682e01fc21a4f2",
+  "candidate-0628-media-music": "f117f79553dbae9ef7f91028c9ec00e0bc3d3a23838a15bbb6c4084bb7a8b2f0",
+  "candidate-0674-ml-evaluation": "70c106794e72d53aee86ee5f12e42cb9380ea02f9f73bf6a0f29f2367b1fe79a",
+  "candidate-0688-hardware-rtl": "0da413d4a536afb3bf35cc9a04822def3ebe79e5a15fe0b774202f68f29859f2",
+  "candidate-0758-ml-inference": "2bfeb9dab9c1955ad4a2c5645e2c32667268a187f30fa89d04020d7ced946b6e",
+  "candidate-0803-ml-training": "ebdda943995031371a0eb4f64498cc8c8e6759f6b597bee053ade046ca18367d",
+  "candidate-0847-software-languages": "3384295c64c7b68a6ece30a27e045c953c0a95db7e1d14887f81ad14ffe2ad24",
+  "candidate-0867-software-frontend": "eb91b790a670790620d9e6729c8ce2148b3bbbdd5f2c184d8642d50f7fb3a119",
+  "candidate-0938-science-chemistry": "ee72c0e85184179d1b8fb209f027326ace11e2d73899b4515972338323eb6218",
+  "candidate-0993-software-systems": "6cf4a9b9249b007cb750d7d88dc915efb1deb1438ddacd6a01023a97456f5263",
+  "candidate-1001-security-forensics": "34dd7286c205daec158dae73d1ea2cc3ec130e6a7183fe762d1f9e0c9f489cb8",
+  "candidate-1005-software-systems": "d7a89ea359ed996ea6e90b33eab2b3b57a2dc71211d482a6cf7dd8fc9d07bdfe",
+  "candidate-1048-operations-virtualization": "f999098ebdbd908db344949c1279d28414e612b018e78ca85454b3673e748c4e",
+  "candidate-1155-software-systems": "bc633b4bb99ff269f6a66f516806663791139cb17554b77462446471d1701339",
+  "candidate-1165-ml-evaluation": "fb0b5a760574dfd30127dbed9aadb43bf37e6c9a1ec792371f77033dcb3977c3",
+  "candidate-1216-software-frontend": "61b385ce1430129e50c69f576d150eade1f7a1e80fc6335b85eccff1bdb9501a",
+  "candidate-1247-security-reverse-engineering": "e5ccb3a280c2078d9fdf9a6bb0114490da104ce3ae913d0442772f3860a9eae4",
+  "candidate-1257-software-systems": "58ea4229ffebed4f232f0289e535afb37a6c69efbb9c6c23bab220005e7f184a",
+  "candidate-1271-media-games": "ac9e68e32b034f1e1c1667d4a9c3c9ef47ac196fda64f76d2ec61401f715f8a8",
+  "candidate-1305-software-data-engineering": "6e95a2e1ff8092bbb77042c7f6216dc4979f3855ec592294120df8d1f55e71a7",
+  "candidate-1399-security-reverse-engineering": "4fd20ed53eae7b42aa830c8b60a45ed4c112a4db045f539f411e6e67e305998d",
+  "candidate-1442-software-languages": "07070f65579122e75440109c96c7443dfc8a636a6849de6457a2fef99c909507",
+  "candidate-1559-ml-evaluation": "bae0a744c896c522fc196d75f0206726095fafe3f3a61136b45e0f42e1189dc7",
+  "candidate-1601-software-data-engineering": "93da5430a8c6d69f9bf66f098955abf80dfb74662ff0c4a7a2ca38d59b5beabc",
+  "candidate-1634-software-databases": "8054a18a9d8984a04f537765ecf55e8ac5398374664444d62536bc0cc7151c6d",
+  "candidate-1669-operations-marketing": "e1437f7e87fe9310ff41093113b6f78f1b62520741d2877c28a333e8a6a23f8d",
+  "candidate-1682-science-physics": "9189f1975d4a7a3391c7ce61fb83438ea8844a7c5442c4051420e74491f8c7f8",
+  "candidate-1702-ml-inference": "a70e7d9266a1d42b1b69e440f46883e0d6e77f4dc694a1085d3cc56ff9eb65fa",
+  "candidate-1736-ml-inference": "5d2d04f1c2807979a9530d350224e1478c2169169c98b118988c1bc2006f4265",
+  "candidate-1789-security-appsec": "3561c90d7a5a546942c1a46ad90e37d881d91b4951c6cbd8c74b70bc037b01c9",
+  "candidate-1824-media-design": "de4b3bb3a6d8f2a434be0df432b82b0b7af74b89e24d46aa11d86ce7b2ce9d3d",
+  "candidate-1836-hardware-cad": "1fdb5e2253397ee78506ad1e9ea52256ae4bc072f9e9bddf653d32405dfc96aa",
+  "candidate-1866-ml-inference": "9579e3d07d973f225ec8fdc0780e2e14750d89f0aea773ff081a978933a54b29",
+  "candidate-1890-ml-training": "7e5cf2a3fc785b11b4cfb7e5e34e075e42cbac881a752804c8dae7d68614d316",
+  "candidate-1939-software-systems": "ee8bdaff360daafb323f153decf776a4e3a601609f3e2d921dd5271aafc52013",
+  "candidate-1990-security-cryptography": "c989345947ee7544a95ad961ae8cfff721db9e0d11fe733bdc69a5ad5c79ca47",
+  "candidate-2072-software-data-engineering": "f576f5ad18c711376de34f480fa471a80ed7c52a39d241bda1a3da77c27ad965",
+  "candidate-2160-software-frontend": "b5d750f262e80d7747fb66d4f5aba3b43f26300a7cc8bc00670e5c98c762fb6c",
+  "candidate-2163-operations-marketing": "a5d1d5a9a6949f091784db364bcbd6cc804b43859bd46591dfda11be47a277f0",
+  "candidate-2207-security-appsec": "ad5935073a4b855a1825b7538b39278bf0247c0e70df821fd37ecdb503602359",
+  "candidate-2262-operations-compliance": "d2990a5eb4642103ca29bdc3c804a27c05777a02552338acc214f90c5edc1464",
+  "candidate-2329-software-languages": "1f63a884b9d536bcf819aad56c4680413ec9da4f820d940bbad8cd430140b81a",
+  "candidate-2376-security-cryptography": "115ad59792ad1217807e86587bfc19783c2bcf0135892cd38c28811a4da65440",
+  "candidate-2487-security-cryptography": "d4ddc417ec0f99a0478658adb651ca0f13fe7c0bd533abd4b7046fc06ffba2a3",
+  "candidate-2500-hardware-cad": "d928fed7354ac6ddef0a6ec79b392bfc05f744d59397c10891a9f4b0c9c9f469",
+  "candidate-2511-security-cryptography": "c114c423a9a26bd5c05b42d58980f1fa3862a025ca77388ca481f3d235be4268",
+  "candidate-2517-software-data-engineering": "4611511b19d1954c8afcfac5d5c914b50bf8d06bcac88f7d6756167e01eda2c6",
+  "candidate-2535-security-cryptography": "fcc9b63ec1b9a19274d2d2086209f07749608272753e84c3c7dd298bbba0c7e6",
+  "candidate-2684-security-appsec": "5d5fba56213b6602bc64a86523a56bc4d3963c70e4f527c896a5969a9876a6a3",
+  "candidate-2713-ml-inference": "70cb790868df3ea15a35f75d1e86e79c909e8670ed83951c3e50f75eb793c2f5",
+  "candidate-2728-software-data-engineering": "156fb9c2f14aba568089ff0f66a86738a2ff273329c140fa113e081cc61831f6",
+  "candidate-2760-ml-inference": "56bfe4745ba1863a02502eae71b8c00c49d7c04f30b1ef384cab4f9076b92951",
+  "candidate-2790-ml-evaluation": "4231188dbfe742e7e58e267b921390ba7274b8d3e329c11e3bc822c2eb7e439e",
+  "candidate-2836-ml-kernels": "7e6a4d96809f5c54fa853f03802616001d746c05bc7ecdc9e280f7adba830ebe",
+  "candidate-2838-ml-evaluation": "f392afbc7858e8241befec59fa943f1c12330974374d6f8abec8f12ee5a59b97",
+  "candidate-2916-ml-training": "dd51ce8fd3e705a0796bb57188efdc1d3bea1106de2ada1f749e938d474b0805",
+  "candidate-2951-security-appsec": "d8beea8664e88b1a2fb14f402b05ae47e678ac897b14e257669ca1ad5532a36c",
+  "candidate-2996-ml-evaluation": "843213d0fb7ae6f2111db984c4e0177c7e500238b07f3292ded056e0160e30f4"
+ }
+}

registry.json

@@ -0,0 +1,265 @@
+[
+ {
+  "name": "mimo-v2.6-rl-harbor-terminal",
+  "version": "1.0.0",
+  "description": "MiMo-V2.6-RL Terminal: 64 Harbor tasks",
+  "tasks": [
+   {
+    "name": "candidate-0036-software-data-engineering",
+    "path": "tasks/candidate-0036-software-data-engineering"
+   },
+   {
+    "name": "candidate-0109-science-robotics",
+    "path": "tasks/candidate-0109-science-robotics"
+   },
+   {
+    "name": "candidate-0260-security-appsec",
+    "path": "tasks/candidate-0260-security-appsec"
+   },
+   {
+    "name": "candidate-0308-security-forensics",
+    "path": "tasks/candidate-0308-security-forensics"
+   },
+   {
+    "name": "candidate-0390-security-appsec",
+    "path": "tasks/candidate-0390-security-appsec"
+   },
+   {
+    "name": "candidate-0461-ml-evaluation",
+    "path": "tasks/candidate-0461-ml-evaluation"
+   },
+   {
+    "name": "candidate-0534-ml-training",
+    "path": "tasks/candidate-0534-ml-training"
+   },
+   {
+    "name": "candidate-0628-media-music",
+    "path": "tasks/candidate-0628-media-music"
+   },
+   {
+    "name": "candidate-0674-ml-evaluation",
+    "path": "tasks/candidate-0674-ml-evaluation"
+   },
+   {
+    "name": "candidate-0688-hardware-rtl",
+    "path": "tasks/candidate-0688-hardware-rtl"
+   },
+   {
+    "name": "candidate-0758-ml-inference",
+    "path": "tasks/candidate-0758-ml-inference"
+   },
+   {
+    "name": "candidate-0803-ml-training",
+    "path": "tasks/candidate-0803-ml-training"
+   },
+   {
+    "name": "candidate-0847-software-languages",
+    "path": "tasks/candidate-0847-software-languages"
+   },
+   {
+    "name": "candidate-0867-software-frontend",
+    "path": "tasks/candidate-0867-software-frontend"
+   },
+   {
+    "name": "candidate-0938-science-chemistry",
+    "path": "tasks/candidate-0938-science-chemistry"
+   },
+   {
+    "name": "candidate-0993-software-systems",
+    "path": "tasks/candidate-0993-software-systems"
+   },
+   {
+    "name": "candidate-1001-security-forensics",
+    "path": "tasks/candidate-1001-security-forensics"
+   },
+   {
+    "name": "candidate-1005-software-systems",
+    "path": "tasks/candidate-1005-software-systems"
+   },
+   {
+    "name": "candidate-1048-operations-virtualization",
+    "path": "tasks/candidate-1048-operations-virtualization"
+   },
+   {
+    "name": "candidate-1155-software-systems",
+    "path": "tasks/candidate-1155-software-systems"
+   },
+   {
+    "name": "candidate-1165-ml-evaluation",
+    "path": "tasks/candidate-1165-ml-evaluation"
+   },
+   {
+    "name": "candidate-1216-software-frontend",
+    "path": "tasks/candidate-1216-software-frontend"
+   },
+   {
+    "name": "candidate-1247-security-reverse-engineering",
+    "path": "tasks/candidate-1247-security-reverse-engineering"
+   },
+   {
+    "name": "candidate-1257-software-systems",
+    "path": "tasks/candidate-1257-software-systems"
+   },
+   {
+    "name": "candidate-1271-media-games",
+    "path": "tasks/candidate-1271-media-games"
+   },
+   {
+    "name": "candidate-1305-software-data-engineering",
+    "path": "tasks/candidate-1305-software-data-engineering"
+   },
+   {
+    "name": "candidate-1399-security-reverse-engineering",
+    "path": "tasks/candidate-1399-security-reverse-engineering"
+   },
+   {
+    "name": "candidate-1442-software-languages",
+    "path": "tasks/candidate-1442-software-languages"
+   },
+   {
+    "name": "candidate-1559-ml-evaluation",
+    "path": "tasks/candidate-1559-ml-evaluation"
+   },
+   {
+    "name": "candidate-1601-software-data-engineering",
+    "path": "tasks/candidate-1601-software-data-engineering"
+   },
+   {
+    "name": "candidate-1634-software-databases",
+    "path": "tasks/candidate-1634-software-databases"
+   },
+   {
+    "name": "candidate-1669-operations-marketing",
+    "path": "tasks/candidate-1669-operations-marketing"
+   },
+   {
+    "name": "candidate-1682-science-physics",
+    "path": "tasks/candidate-1682-science-physics"
+   },
+   {
+    "name": "candidate-1702-ml-inference",
+    "path": "tasks/candidate-1702-ml-inference"
+   },
+   {
+    "name": "candidate-1736-ml-inference",
+    "path": "tasks/candidate-1736-ml-inference"
+   },
+   {
+    "name": "candidate-1789-security-appsec",
+    "path": "tasks/candidate-1789-security-appsec"
+   },
+   {
+    "name": "candidate-1824-media-design",
+    "path": "tasks/candidate-1824-media-design"
+   },
+   {
+    "name": "candidate-1836-hardware-cad",
+    "path": "tasks/candidate-1836-hardware-cad"
+   },
+   {
+    "name": "candidate-1866-ml-inference",
+    "path": "tasks/candidate-1866-ml-inference"
+   },
+   {
+    "name": "candidate-1890-ml-training",
+    "path": "tasks/candidate-1890-ml-training"
+   },
+   {
+    "name": "candidate-1939-software-systems",
+    "path": "tasks/candidate-1939-software-systems"
+   },
+   {
+    "name": "candidate-1990-security-cryptography",
+    "path": "tasks/candidate-1990-security-cryptography"
+   },
+   {
+    "name": "candidate-2072-software-data-engineering",
+    "path": "tasks/candidate-2072-software-data-engineering"
+   },
+   {
+    "name": "candidate-2160-software-frontend",
+    "path": "tasks/candidate-2160-software-frontend"
+   },
+   {
+    "name": "candidate-2163-operations-marketing",
+    "path": "tasks/candidate-2163-operations-marketing"
+   },
+   {
+    "name": "candidate-2207-security-appsec",
+    "path": "tasks/candidate-2207-security-appsec"
+   },
+   {
+    "name": "candidate-2262-operations-compliance",
+    "path": "tasks/candidate-2262-operations-compliance"
+   },
+   {
+    "name": "candidate-2329-software-languages",
+    "path": "tasks/candidate-2329-software-languages"
+   },
+   {
+    "name": "candidate-2376-security-cryptography",
+    "path": "tasks/candidate-2376-security-cryptography"
+   },
+   {
+    "name": "candidate-2487-security-cryptography",
+    "path": "tasks/candidate-2487-security-cryptography"
+   },
+   {
+    "name": "candidate-2500-hardware-cad",
+    "path": "tasks/candidate-2500-hardware-cad"
+   },
+   {
+    "name": "candidate-2511-security-cryptography",
+    "path": "tasks/candidate-2511-security-cryptography"
+   },
+   {
+    "name": "candidate-2517-software-data-engineering",
+    "path": "tasks/candidate-2517-software-data-engineering"
+   },
+   {
+    "name": "candidate-2535-security-cryptography",
+    "path": "tasks/candidate-2535-security-cryptography"
+   },
+   {
+    "name": "candidate-2684-security-appsec",
+    "path": "tasks/candidate-2684-security-appsec"
+   },
+   {
+    "name": "candidate-2713-ml-inference",
+    "path": "tasks/candidate-2713-ml-inference"
+   },
+   {
+    "name": "candidate-2728-software-data-engineering",
+    "path": "tasks/candidate-2728-software-data-engineering"
+   },
+   {
+    "name": "candidate-2760-ml-inference",
+    "path": "tasks/candidate-2760-ml-inference"
+   },
+   {
+    "name": "candidate-2790-ml-evaluation",
+    "path": "tasks/candidate-2790-ml-evaluation"
+   },
+   {
+    "name": "candidate-2836-ml-kernels",
+    "path": "tasks/candidate-2836-ml-kernels"
+   },
+   {
+    "name": "candidate-2838-ml-evaluation",
+    "path": "tasks/candidate-2838-ml-evaluation"
+   },
+   {
+    "name": "candidate-2916-ml-training",
+    "path": "tasks/candidate-2916-ml-training"
+   },
+   {
+    "name": "candidate-2951-security-appsec",
+    "path": "tasks/candidate-2951-security-appsec"
+   },
+   {
+    "name": "candidate-2996-ml-evaluation",
+    "path": "tasks/candidate-2996-ml-evaluation"
+   }
+  ]
+ }
+]

tasks/candidate-0036-software-data-engineering/environment/Dockerfile

@@ -0,0 +1,3 @@
+# The task's image, pinned by digest (the same as [environment].docker_image).
+# Setup runs at start from [environment.healthcheck]; environment/setup/ is its readable copy.
+FROM docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:3db4bdcb19504df7b6a9ad1de3ed33b7ec32340dcb4ff108b6b947af39cd5bee

tasks/candidate-0036-software-data-engineering/environment/setup/setup.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Runs once, as root, before the agent starts: Harbor's [environment.healthcheck] unpacks this folder into
+# /var/lib/mimo and runs it. Generated by mimo_harbor; see its README for how each step maps to Xiaomi's harness.
+M=/var/lib/mimo
+[ -f "$M/ready" ] && exit 0
+chmod 700 "$M"
+fail() { echo "setup: $*" >&2; exit 1; }
+# the answer-leak blocklist (mimoagent), applied to /etc/hosts by the agent right after it installs
+write_blocklist() { cp "$M/files/blocklist" "$M/blocklist"; }
+
+# Terminal-Bench rows (in the General domain): the Harbor convention itself. Scrub test leftovers from the image and
+# remember what was in the workspace, so harness residue can be told apart from the agent's work at grading time.
+rm -rf /tests
+find /logs/verifier -mindepth 1 -delete 2>/dev/null || true
+ls -A /app 2>/dev/null > "$M/before" || true
+
+touch "$M/ready"
+echo "setup done"

tasks/candidate-0036-software-data-engineering/instruction.md

@@ -0,0 +1,30 @@
+You are an agent, your current working directory is /app.
+
+You can use the tools available to you to interact with the computer to assist the user in completing tasks.
+
+# Repair wildcard output flags in the workflow engine
+
+You are given a frozen, pre-fix Snakemake source tree at
+`/app/vendor/snakemake`. A data workflow declares several output patterns with
+wildcard constraints. Some outputs are marked `touch`, `temp`, `protected`,
+`pipe`, or `service`. After a rule is expanded for a concrete wildcard value,
+the resulting job must retain the flags attached to that concrete output.
+
+Diagnose the interaction between output declaration in
+`src/snakemake/rules.py` and concrete job construction in
+`src/snakemake/jobs.py`. Repair the existing production modules so flag
+classification is based on the expanded output object and remains correct for
+all of the flags above. Do not special-case the sample names, remove wildcard
+constraints, or add shell commands that manufacture marker files.
+
+Run the three-stage offline integration replay:
+
+```sh
+cd /app
+python3 workflow_probe.py
+```
+
+It must write `/app/output.json` with schema version `workflow-repair-1`, two
+concrete wildcard jobs, one touch output per job, preserved temp/protected and
+pipe/service categories, and a completed downstream aggregate. The replay is
+only valid when both existing source modules have been repaired.

tasks/candidate-0036-software-data-engineering/task.toml

@@ -0,0 +1,39 @@
+schema_version = "1.4"
+
+[task]
+name = "mimo-v2.6-rl/candidate-0036-software-data-engineering"
+description = "MiMo-V2.6-RL terminal task candidate-0036-software-data-engineering"
+keywords = ["mimo-v2.6-rl", "terminal"]
+
+[metadata]
+adapter = "mimo_harbor 1.0.0"
+domain = "terminal"
+original_allow_internet = false
+reference_harness = "XiaomiMiMo/verl a2ad9f6 + XiaomiMiMo/mimoagent 467f0a1"
+reference_step_limit = 500
+source_dataset = "XiaomiMiMo/MiMo-V2.6-RL-oss"
+source_id = "candidate-0036-software-data-engineering"
+source_revision = "639865fd3374018d6cb29b9fb82dd531406fcf5f"
+
+[agent]
+timeout_sec = 900.0
+
+[verifier]
+timeout_sec = 240.0
+user = "root"
+
+[environment]
+docker_image = "docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:3db4bdcb19504df7b6a9ad1de3ed33b7ec32340dcb4ff108b6b947af39cd5bee"
+workdir = "/app"
+cpus = 1
+memory_mb = 2048
+storage_mb = 10240
+network_mode = "public"
+build_timeout_sec = 1800.0
+
+[environment.healthcheck]
+# one-time setup before the agent (environment/setup/setup.sh)
+command = "bash -c 'test -f /var/lib/mimo/ready || { mkdir -p /var/lib/mimo && echo H4sIAAAAAAAC/+2T30/UQBDH77l/xddCEAx3PVAhgUiCkegLL+iDCSFk206vm9vuNrvbq0T83532gJP4qr44n5e2+2PmO9+ZBopdOwv15C8yZ47n8/E5//158Pbo8PH9Yf34zeujCeaTf0AXovKccvJ/svUiy7XNchXqZAtXnQ1wtqB9qADvXNxHTpXzhFgT1IJsxGBYDCf4pHzu/MuAa7Ir7Z1teHdWkzKxLmoqljfobKuKZeDLOqBypiQPbaPjVNlK+czoPGt046BsCT8k13GGj2TJq0gl8jsM27f1mOoUgYhPBFxdnH+4vOCIHrXrQaqoWRa1aFTL2Ry+auUazdr4pqUQZsnlu2cZk2tMK6Tbl5knVd6luMHODuibjpgnRd24Ejyyw4E0qZQ2u3v4DipqhzQMv8wJtl+lONs5PF1fOjjFD65qdMmGnvzUkFoiN65YGh0idoeso4F7bG7bGs31sdKMYpHVLnBVXO3GZa8XdYSq4mBZZNfYdmNC0nsd6fYp7qiraMdKKm0oZE9b6bi4+RwUssQv5BttlZm+J8u2edcH7Go7pl47b1C6Rmm7dzIurvuMwtkVC9PODi0gU83wufBdjkhcnqEquhV5brN3zXhPN1zJ0FlO6qmhJudS+lpF9DxcDxl755eBh4QnLrjHbvHxoMuOUCjL88c2mZI947HbRB9d4gYPAcAxF16V2i4QdUOzxDeY+grZoC0klebxyoxbhIwl6kqzkCmbUFIbaxxgWpKhSDg8y0paZbYzBvf3iL6jxARMz5Fxx55tn63NHf+N9OlwEl3Hnm7GKvllZNhVS2kyEQRBEARBEARBEARBEARBEARBEARBEARBEIQ/xk8LxjaZACgAAA== | base64 -d | tar -xzf - -C /var/lib/mimo && bash /var/lib/mimo/setup.sh; }'"
+timeout_sec = 1200.0
+retries = 0
+interval_sec = 5.0

tasks/candidate-0036-software-data-engineering/tests/anti_hack_guard.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""TBench in-pod anti-hack guard.
+
+Runs at the very start of ``tests/test.sh``, inside the verifier container,
+after the agent's ``/app`` has been copied in.  The RL harness materialises
+``tests/`` into the MAIN container only after the agent exits, so the agent
+cannot see or tamper with this file — which makes it the right place to reject
+workspace pollution the agent planted during the episode.
+
+Detection (any hit -> write reward=0 and exit non-zero):
+
+1. **Planted interpreter hooks.**  ``conftest.py`` / ``sitecustomize.py`` /
+   ``usercustomize.py`` / ``*.pth`` / ``pytest.ini`` / ``.coveragerc`` /
+   ``tox.ini`` anywhere under ``/app`` whose path is NOT listed in the pristine
+   manifest.  Upstream vendor trees that legitimately ship a ``conftest.py``
+   are listed in the manifest and are therefore not false positives.
+2. **Protected-file mutation.**  Any manifest entry whose sha256 changed while
+   its path is outside the declared mutable set.
+3. **Protected-file deletion.**  Any non-mutable, non-artifact manifest entry
+   that vanished.
+
+The manifest is generated from the pristine ``environment/`` tree and shipped
+as ``tests/fixtures/pristine_env_manifest.json``.  A missing manifest degrades to
+name-only detection so the guard never blocks an uninstrumented task.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+SCHEMA = "tbench.pristine_env_manifest.v1"
+
+APP = Path(os.environ.get("TBENCH_APP_ROOT", "/app"))
+FIXTURES = Path(os.environ.get("TBENCH_FIXTURES", "/tests/fixtures"))
+MANIFEST = FIXTURES / "pristine_env_manifest.json"
+REWARD = Path(os.environ.get("TBENCH_REWARD_FILE", "/logs/verifier/reward.txt"))
+
+DANGEROUS_NAMES = {
+    "conftest.py",
+    "sitecustomize.py",
+    "usercustomize.py",
+    "pytest.ini",
+    ".coveragerc",
+    "tox.ini",
+    "pyproject.toml",  # only dangerous when planted; upstream copies are in the manifest
+}
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def is_dangerous(rel: str) -> bool:
+    name = rel.rsplit("/", 1)[-1]
+    return name in DANGEROUS_NAMES or name.endswith(".pth")
+
+
+def load_manifest() -> dict | None:
+    if not MANIFEST.is_file():
+        return None
+    try:
+        doc = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(doc, dict) or not isinstance(doc.get("files"), dict):
+        return None
+    return doc
+
+
+def reject(reason: str, reward: Path | None = None) -> int:
+    target = REWARD if reward is None else reward
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text("0\n", encoding="utf-8")
+    except OSError as exc:  # pragma: no cover - reward file is the contract
+        print(f"anti_hack_guard: cannot write reward file: {exc}", file=sys.stderr)
+        return 2
+    print(f"anti_hack_guard: REJECT {reason}", file=sys.stderr)
+    return 1
+
+
+def scan(manifest: dict | None, app: Path | None = None) -> str | None:
+    app_root = APP if app is None else app
+    files: dict[str, str] = (manifest or {}).get("files") or {}
+    mutable_set = {
+        entry.lstrip("/")
+        for entry in (manifest or {}).get("mutable") or []
+        if isinstance(entry, str)
+    }
+    artifacts = {
+        str(entry).removeprefix("/app/").lstrip("/")
+        for entry in (manifest or {}).get("artifacts") or []
+        if isinstance(entry, str)
+    }
+
+    if not app_root.is_dir():
+        return None
+
+    for path in sorted(app_root.rglob("*")):
+        if not path.is_file() or path.is_symlink():
+            continue
+        rel = path.relative_to(app_root).as_posix()
+        if is_dangerous(rel) and rel not in files:
+            return f"planted_interpreter_hook:{rel}"
+
+    if manifest is None:
+        return None
+
+    # Deletion detection is only sound when the built image is known to equal
+    # the source tree (plain ``COPY . /app``).  A multi-stage or dockerignored
+    # build legitimately omits files, and rejecting those would zero out the
+    # oracle for a perfectly good task.
+    detect_deletion = bool(manifest.get("detect_deletion", True))
+    for rel, expected in files.items():
+        if rel in mutable_set or rel in artifacts:
+            continue
+        path = app_root / rel
+        if not path.exists():
+            if detect_deletion:
+                return f"protected_file_deleted:{rel}"
+            continue
+        if not path.is_file():
+            continue
+        if sha256(path) != expected:
+            return f"protected_file_mutated:{rel}"
+    return None
+
+
+def main(app: Path | None = None, reward: Path | None = None) -> int:
+    manifest = load_manifest()
+    reason = scan(manifest, app=app)
+    if reason:
+        return reject(reason, reward=reward)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tasks/candidate-0036-software-data-engineering/tests/fixtures/pristine_env_manifest.json

@@ -0,0 +1,189 @@
+{
+  "artifacts": [
+    "output.json"
+  ],
+  "detect_deletion": true,
+  "files": {
+    "Dockerfile": "fdc4026cc5e1301ffb6bdfd12f61c9d1591909ddf05501b43ef6ade47d01641f",
+    "vendor/snakemake/LICENSE.md": "84a1a82b05c80637744d3fe8257235c15380efa6cc32608adf4b21f17af5d2b8",
+    "vendor/snakemake/pyproject.toml": "1937a29334f91bf13b3874e56a36cf352f9dff95a1946009e719d41f0875316a",
+    "vendor/snakemake/setup.py": "5c64dffbead198991a469f19799638f9254830c58a75137e65c85e7c334d6433",
+    "vendor/snakemake/src/snakemake/__init__.py": "dab4e1cf0f0c2ea7a529813463fd580f5569174016c7bd2471ca17c2c49fc9df",
+    "vendor/snakemake/src/snakemake/__main__.py": "6eb6fcf7d23145d839c876385cc1652edf95e77cda88f016956a0865a9b76411",
+    "vendor/snakemake/src/snakemake/api.py": "116c61f2e847138d6ab60a31acbc1bf4e2eafcf30310eb9f67752ea723420ee3",
+    "vendor/snakemake/src/snakemake/assets/__init__.py": "3d61fab4b4aca726a8c6f5fda37862b8f4bf3a277ebed399cc6fe850edd3df6b",
+    "vendor/snakemake/src/snakemake/benchmark.py": "2d584d8aa2ad44e4f9b776d787a9454a31704a91fdd6fac00d1430cd066468d7",
+    "vendor/snakemake/src/snakemake/caching/__init__.py": "51bf59c5ad1e23299d5c38fc1834252fcf53cddf2809c81b713573d2c25a9884",
+    "vendor/snakemake/src/snakemake/caching/hash.py": "e9b337e8160d3ff59fbbf8f4a34fdb4ffd746cd194ae02b2c2fcafdacfd22ee7",
+    "vendor/snakemake/src/snakemake/caching/local.py": "db3eb9941c25612efd1ba3c0446ae0852ca661bf9c36ec2cc6c790e6b15c8254",
+    "vendor/snakemake/src/snakemake/caching/rule.py": "8046a615c13aed12fea79f536665ae22c65d4252eda0f43f9891d803ba48f713",
+    "vendor/snakemake/src/snakemake/caching/storage.py": "430652b1b7aaaea0f08eddc65248cfa34535cc06c19e3c9c967ba5cefe639458",
+    "vendor/snakemake/src/snakemake/checkpoints.py": "63bd405feabcb766394a6c3d233ec773003433986ae72d8dcf3988a2895d7a67",
+    "vendor/snakemake/src/snakemake/cli.py": "6d0a58ba17467c0502e5ee4db474cca96e5824bf17f2491d8619abe9e8ebe7fb",
+    "vendor/snakemake/src/snakemake/common/__init__.py": "31cd20c19570029e869e1616b7f27bb324b85f9a76fb4a45ec083267fe22775a",
+    "vendor/snakemake/src/snakemake/common/argparse.py": "7bb31176289a77f5c88a0da1cb1487e5b6579358af588d9966e0d8586ecc6057",
+    "vendor/snakemake/src/snakemake/common/configfile.py": "627554d16b1bbe23cb3fc494d2a6b8cd2d8d866156a554f7809a6bcecf65ce7d",
+    "vendor/snakemake/src/snakemake/common/git.py": "ee32c2a93aaa37775b2dbf90f169bbec26422b18a967473b698d3a0f8892a2d5",
+    "vendor/snakemake/src/snakemake/common/prefix_lookup.py": "0ca682cca4ee92788b29de018af1e46fb65e9b302b5477f71499ea8159243bed",
+    "vendor/snakemake/src/snakemake/common/tbdstring.py": "b871af8a936c80cd6a41e405a176eefd47481f426480be405dbf821140aa9c91",
+    "vendor/snakemake/src/snakemake/common/tests/__init__.py": "dbc02225640ae546642484144ca4feac3481c51874853caab81a9d9e2d325523",
+    "vendor/snakemake/src/snakemake/common/tests/testcases/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/snakemake/src/snakemake/common/tests/testcases/groups/Snakefile": "d6f49137275c06d427ef97afc3820ffcb098280b9f31c16d0e748a75f861127f",
+    "vendor/snakemake/src/snakemake/common/tests/testcases/groups/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/snakemake/src/snakemake/common/tests/testcases/groups/caption.rst": "08c981c6cfb74653148183fbfba36e06ebdfb34c899e37f1fbeef7df463d4266",
+    "vendor/snakemake/src/snakemake/common/tests/testcases/simple/Snakefile": "140317465a0a9c36d1010bc09dd7e237670ca677c176b144c8c7bb0308f767e9",
+    "vendor/snakemake/src/snakemake/common/tests/testcases/simple/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/snakemake/src/snakemake/common/tests/testcases/simple/caption.rst": "08c981c6cfb74653148183fbfba36e06ebdfb34c899e37f1fbeef7df463d4266",
+    "vendor/snakemake/src/snakemake/common/typing.py": "5902e351d222ab80090005365538ad343435faa192bea43d7277cd118fbf2edf",
+    "vendor/snakemake/src/snakemake/common/workdir_handler.py": "afd6fc2f0f6c00a78a07948d819698760470795e33c6bf48e06de84d48d10d06",
+    "vendor/snakemake/src/snakemake/cwl.py": "6fc587e23b2fd39a30d1b4f87b64f15c45a2d8825bdd15b39f4ef54f9f0613d2",
+    "vendor/snakemake/src/snakemake/dag.py": "6a378445fc007c7c540f2d814d09647736323bfbfc2a93aad58d83cb8ba0601a",
+    "vendor/snakemake/src/snakemake/decorators.py": "c0dd23927107cd09ca18010bf2e56b3ef69678e6efc86582a373a917ee149982",
+    "vendor/snakemake/src/snakemake/deployment/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/snakemake/src/snakemake/deployment/conda.py": "ad43a8b87ed5c04739bda1233945e64291372718cb27e12b3bceed3325526798",
+    "vendor/snakemake/src/snakemake/deployment/containerize.py": "655c4994c147b2db276743a4e1cfb7e046c1286757cd21916322b65b3ae7ab43",
+    "vendor/snakemake/src/snakemake/deployment/env_modules.py": "47377c055cb16fe50f0f8cf48369488e40deb53ecde5013bf11270ca0325bef5",
+    "vendor/snakemake/src/snakemake/deployment/singularity.py": "225a2de2b3e6e2b91a24de7e902f3542ae7471223147410ad2ea9bb81e30d80b",
+    "vendor/snakemake/src/snakemake/exceptions.py": "8f144d1a917e54ce8c0f9edbe0fb0ca4cbb559a82bf005c479e18e8d8b242245",
+    "vendor/snakemake/src/snakemake/executors/__init__.py": "10f53792bc5fe4c4d278d950489ac50447f6ad08e27113d4023574385baf51c1",
+    "vendor/snakemake/src/snakemake/executors/dryrun.py": "84911980aa2ec670d5cac0b6f082bd466f288af21c98adb9d00759468975de90",
+    "vendor/snakemake/src/snakemake/executors/google_lifesciences_helper.py": "efd0425032af03ceb57043e9b220eddb573806a3bf8d48c0475947c021428bba",
+    "vendor/snakemake/src/snakemake/executors/jobscript.sh": "ed79806bcddf7ad8d28613d390a0da25f9cdd4b9d694b32b98cd5b13a2ae4ef3",
+    "vendor/snakemake/src/snakemake/executors/local.py": "c76bd06604c9d75ad3b079b75fbefa4cb89a507015df25414c1d1a9cd3b35d3e",
+    "vendor/snakemake/src/snakemake/executors/touch.py": "cb9a9c9272a818c6c806bbabf81ac18b5ad84dfe2983dd5ddf43f0e23c0d109e",
+    "vendor/snakemake/src/snakemake/gui.html": "e05ffd18ced5b895e056a64c1f664a8109efbd11e04e5ea41e4322361a36194a",
+    "vendor/snakemake/src/snakemake/gui.py": "e8d357d20e1550c8830ca3b38953aa05b0e1d0b3064d5028ebc589694dfc7df8",
+    "vendor/snakemake/src/snakemake/io/__init__.py": "5649e207cfc0327c0d6dc8f3b8abd96ff2785ae53bfdf2ac09a5675e4e89063b",
+    "vendor/snakemake/src/snakemake/io/flags/__init__.py": "88dd48f7843cdd63dadff180c22c2eb9155f2cc9cf28873537af675468e1b33a",
+    "vendor/snakemake/src/snakemake/io/flags/access_patterns.py": "84f524efa7b7af46c2f246dbdd239fb8cfd4bd08addb1530093488a0ce18f40a",
+    "vendor/snakemake/src/snakemake/io/fmt.py": "097c20187143962e8d5558d800ec633dc7037446dd7bee77bbfce87f8d91dd71",
+    "vendor/snakemake/src/snakemake/iocontainers.py": "f48ce33373615ec8ea6885c0d8a57b1185c4628ff8f9c1b92081560437625bf6",
+    "vendor/snakemake/src/snakemake/ioflags.py": "dcc82e3b853bc817204cead484e87f246b50d67e81ce99c30f8d7d80663c5def",
+    "vendor/snakemake/src/snakemake/ioutils/__init__.py": "e2e461335a7b225aeb660600aa0848d536d5cd3859c2ad57d7d5031c42f8657c",
+    "vendor/snakemake/src/snakemake/ioutils/as_py_module.py": "4d9e11b9883cccc8a0d94b0c9e8bba5ae4d618dcc7d99c68aafd7b790049f93b",
+    "vendor/snakemake/src/snakemake/ioutils/branch.py": "65c5b6dc326eb505676b3b51260db1052c6553b4411ddcb0daf72250eb2b75b7",
+    "vendor/snakemake/src/snakemake/ioutils/choose_f.py": "aae51ab976d19f7100b8e9b26b90bdd6c18b01e43497494807f987586856473e",
+    "vendor/snakemake/src/snakemake/ioutils/collect.py": "b8f29911f0c065d42cdc8d0fe20a08b94a30bbcd3b9c481d68ce1ddb304cb934",
+    "vendor/snakemake/src/snakemake/ioutils/evaluate.py": "f4a9760c2ec37caec9996d37689dce10ab69e098a90b52c4bda8663468f1dc6f",
+    "vendor/snakemake/src/snakemake/ioutils/exists.py": "81dd4b6ce747128920ba7d097796c7fd3c5cd0dad318d64e314fc2a7066aec89",
+    "vendor/snakemake/src/snakemake/ioutils/input.py": "f8f4132606a51e40b10771de37aaee68e7b92c99d16ebdb2ef5144761e7b1991",
+    "vendor/snakemake/src/snakemake/ioutils/lookup.py": "4ccb4dd4c8b991637791e5a372d0afc0051b21325ac4002747f30011145ee4f9",
+    "vendor/snakemake/src/snakemake/ioutils/prepend_param.py": "6e7d11de298a1c1475a30b7f9dc9045ce81848d5e1900ade17a5913e314aa928",
+    "vendor/snakemake/src/snakemake/ioutils/rule_items_proxy.py": "0913fd93a43d6a46e7967e1be4c7d641ec91c1a1f0185968a648160110213d92",
+    "vendor/snakemake/src/snakemake/ioutils/subpath.py": "d63979efb68a1d1d9f7914ea1fc01343cbf9abad26a5652a095c00c25ffbe901",
+    "vendor/snakemake/src/snakemake/jobs.py": "67fce1e4ab3c8818f960e7f73a77c8bb1c2ef1bb5a9ef093277bbf077b691233",
+    "vendor/snakemake/src/snakemake/linting/__init__.py": "f416d32e35ef5d46aa4e7e7394ec5655b1be8d079190b412057fec3ebb7320c6",
+    "vendor/snakemake/src/snakemake/linting/links.py": "bccc585979845ac1980be97ad6289bc0cfea3e27a8259f8dfb19c30c3d5c3138",
+    "vendor/snakemake/src/snakemake/linting/rules.py": "e7b121aa440a7fa1495ed82838dd997378d8a9a9f10af48d5b8519e531e11ef5",
+    "vendor/snakemake/src/snakemake/linting/snakefiles.py": "2339726ef6e3b75262ffefd20e3db0593cdb2cc099e1e383af132add1cdabb5a",
+    "vendor/snakemake/src/snakemake/logging.py": "7e125dd6c659be229fc4d49df6b74fe45ce73065efef73d318e54968f53100fa",
+    "vendor/snakemake/src/snakemake/modules.py": "7444d1ea0d40a03a565b887f2c5ddea029d4d58aef732a74efff9dd323f50c3b",
+    "vendor/snakemake/src/snakemake/notebook.py": "e54d64bd874d3dad2e55a8c8ebf46f06280182b77e31ead055799f08bca6e90a",
+    "vendor/snakemake/src/snakemake/output_index.py": "e7ed42c6b4efb530727109274e21aeb1052d493d99327fc437d0a58e55f26503",
+    "vendor/snakemake/src/snakemake/parser.py": "865b8b1d7fa499b802b5449d0ca57a9ebfaddd4244aad54b5fe0ace86d6945c5",
+    "vendor/snakemake/src/snakemake/path_modifier.py": "a686c7c9e91631675a728cda38e9bd3113310b9d77180dd30cb52cdcff3b841d",
+    "vendor/snakemake/src/snakemake/pathvars.py": "5a9eda0a5c7a99bddb5913f475740b6e9d35e52be6497fb6805c6599d803a2fa",
+    "vendor/snakemake/src/snakemake/persistence/__init__.py": "94bc0898e6ad47733feb26157264b2f72419fe46ea7197af23720131e78ddc76",
+    "vendor/snakemake/src/snakemake/persistence/db.py": "6c96f2011a3e6f3d5eab06008d4c269a6507327636e62234471d2d8e169d2d13",
+    "vendor/snakemake/src/snakemake/persistence/file.py": "24b7ea54a7fe655cea513da1dd6ab5a9c271a4c681aa4e0c8f8f7b25c87c2955",
+    "vendor/snakemake/src/snakemake/profiles.py": "de87abdb878ece91739d9e9d358a1c2eb5caefd0ad0cffd2ddc0b11db683a2ab",
+    "vendor/snakemake/src/snakemake/remote/AzBlob.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/EGA.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/FTP.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/GS.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/HTTP.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/NCBI.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/S3.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/S3Mocked.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/SFTP.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/XRootD.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/__init__.py": "77b2c34790ed76e19e1b01860f29fae99b47b9ed11746d53cb37c6bb7fc75f3f",
+    "vendor/snakemake/src/snakemake/remote/dropbox.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/gfal.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/gridftp.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/iRODS.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/webdav.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/remote/zenodo.py": "cbf5d143e233572bb4deea67d43e081876f98b98131d46066f55f830a770ef6c",
+    "vendor/snakemake/src/snakemake/report.css": "046ba4606c51847dc033c4ef0f0e954230fc3b568b376e702016aed865390fc3",
+    "vendor/snakemake/src/snakemake/report/__init__.py": "a1b979991f334a5d1dd762a58e5ed4363cf186b8bb3ff5e6ce530fcd81a02256",
+    "vendor/snakemake/src/snakemake/report/common.py": "4cd04e1f4e37973abad9129137924ee29d3c1e48592cb828f855fbbc3248f72b",
+    "vendor/snakemake/src/snakemake/report/html_reporter/__init__.py": "35dc204ff4932370638f368dbc3d1001788fed7da7140812f9aa00aa3d494df5",
+    "vendor/snakemake/src/snakemake/report/html_reporter/common.py": "fb84e853be8779a92e8fe7b38dfb9ce1b7ab542333c874750f4cf5035d62b465",
+    "vendor/snakemake/src/snakemake/report/html_reporter/data/__init__.py": "c72413542775bf42bb2a19a2d50b9f6ff9b270f600e3ebc5e4ac9c1307413bd3",
+    "vendor/snakemake/src/snakemake/report/html_reporter/data/categories.py": "5bf7ae34f5b73dc143bff93dd29854f1575c52e178184fc5ddc3f81dcd120699",
+    "vendor/snakemake/src/snakemake/report/html_reporter/data/common.py": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+    "vendor/snakemake/src/snakemake/report/html_reporter/data/configfiles.py": "1394534d8fd552501e8dbdd8430c71231a40296540a7bfc4cdbae5b3c01f9707",
+    "vendor/snakemake/src/snakemake/report/html_reporter/data/metadata.py": "c12a495e62ec6658746384c60a5fbe15fe5036041d2d943e477945c0f2ee42a9",
+    "vendor/snakemake/src/snakemake/report/html_reporter/data/packages.py": "50bdaaa6e33956c5b1702225b46c8a49bb0b5da24131235084b5e63c45f272ef",
+    "vendor/snakemake/src/snakemake/report/html_reporter/data/results.py": "3c7c7c25142d5670301e11f3ffb77795e69271ce0167616a0ec5a7a566c2e2d8",
+    "vendor/snakemake/src/snakemake/report/html_reporter/data/rulegraph.py": "c78e623161127dcd0aa7eb4b7e2f2e5fff1a7f0885093bde49ba844faf6cbc30",
+    "vendor/snakemake/src/snakemake/report/html_reporter/data/rules.py": "e9df962f688f9b56a5171d89cf21b43af28c1879bf3211635cd8412f614651d1",
+    "vendor/snakemake/src/snakemake/report/html_reporter/data/runtimes.py": "16306adbc21d846da084523ebebe9d467ee2824e396bfd0ac2a65da78ec46b13",
+    "vendor/snakemake/src/snakemake/report/html_reporter/data/timeline.py": "93b95408bde8dd8c25bfae3b5a19ebaa11f339a90ea5e5a2537009963d610ec0",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/abstract_menu.js": "611c4ac0a95fcfdecf6b7155af47a9df59a2a060d0df03dafcd72ed0fadbefab",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/abstract_results.js": "8e3aaf014bbe1f0f5255f2f344993bfed2650215d9bfa6576012c7ad4ef4033c",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/abstract_view_manager.js": "b7f7745b4a194e52f07cb1dee45963d048d68be8a5873e715c192a701510fbb8",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/app.js": "03a26e28ae65865d1ee2b1f86e414b46e1182f16f36c758253b41ce8b9d72dc2",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/breadcrumbs.js": "e2488d0a9e6df19953de0cbf864802ffb654566fd7f36451f69d6ec9bdf1eaaa",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/button.js": "42093ec4124d6a01058180fe84e0f59755a3f76fbebea71c303bf0543038c035",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/category.js": "07a6f837392bc2285eeca86f1424b86bc87d25cd5ae58ada1c6a5797a2c3345a",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/common.js": "c65a3a2b7c1028be09350278ae0540564c3237d202012f1424058878632c123a",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/content.js": "d85d47aea35066c60fc663935d083b81750f11240b337de2144ea62842c78160",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/icon.js": "309f8521d2d65b6d5f225118611da785d36aefd762c80b9bec2c6067e4633434",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/list_heading.js": "c84e982f2cf7f9b2d82cdb01c194b46406c4763bd4c2c29daf3a71f6cf75cd22",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/list_item.js": "9327eaca7b07fc7f77415a00eb8e831e9bee6e58fe3e82eb8f62608d9480f8a7",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/menu.js": "6031c97e922f83e176122b634046ec118bf7f44152d27fcf9803fa07524ef2d1",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/metadata.js": "8e662a37e819d05fa7cce59198f2a26d9b84940501bfdbae8f6f87ca4abc0809",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/navbar.js": "6af37bb368e93caafa9eb1f0a9feb5725c9deb9d9fa5843a512f6b218ad866e1",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/report_info.js": "0ca7da67906f3d093a6c50fa4f3eea824f3adeef958565abf0c56210768aa921",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/result_info.js": "1503d34852d6824e2fb5294fc723554ac7314bd02f4bfaf4d10c4fe0bf7ed12a",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/result_view_button.js": "4c1729bcf3afb117511f058fb3a27b88a59302cbb7adb7ef003ff371836e9520",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/rule_graph.js": "4b227f5c9d435e06369f10409580ec898f72dcefb27ec959060d7193d3797caa",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/rule_info.js": "b7956fb09946a22a4f476797ddee07cab5203358711655cde66120ed8c0397e1",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/search_results.js": "7c2942ff05c45d40217e2547fac162048786444c01967f95f6aa24f918493e3f",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/stats.js": "91441e232e63cf9b0260301091f69518a97a4023606f97a4cc977878ad709326",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/subcategory.js": "10d5750928f1024494b91f5233dc9141c60d9beca9584b4167b81bb79763ac1b",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/components/toggle.js": "e72d39008fbf94e32a42ceef594af019492d30606507f148d7888d5deda07a21",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/index.html.jinja2": "42ced56d029328541a9babab572884132816a43016288cdc3713b113e16c7d47",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/logo.svg": "efb331345b5846783544d572c73825b325405f4d274ea2e099d046e16c01e529",
+    "vendor/snakemake/src/snakemake/report/html_reporter/template/style.css": "57274c23d2cf891f38b3d238a5e9778378aac8ee52e6a5f3a226b059462770ed",
+    "vendor/snakemake/src/snakemake/report/rulegraph_spec.py": "2ba9679658d3381ce0ca81e272ae03ea9d460f991a4d7fad2c9396c5c09a071c",
+    "vendor/snakemake/src/snakemake/resources.py": "82f7ef640ccbc770a0392d1f0e6a6457c81cff53af449931751d55c40a435119",
+    "vendor/snakemake/src/snakemake/ruleinfo.py": "e39f8111ddb1e1afa7bf315a39ead50787d2ac08db5faacadbeae7bffbff9e98",
+    "vendor/snakemake/src/snakemake/rules.py": "3fa8657b9077ff76d1fb25c4fdab2d6a825d0330f4edb04dfb35b05723c509d0",
+    "vendor/snakemake/src/snakemake/scheduling/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/snakemake/src/snakemake/scheduling/greedy.py": "f420eec0e86ee0175160af2bac4b15c88e388a5048bfc76d3aff600fb5f9a0a1",
+    "vendor/snakemake/src/snakemake/scheduling/job_scheduler.py": "0b8c4b8c40d36affe4619bbc302f15616ac806e083fcb4c1aae0b45eb6e3a6aa",
+    "vendor/snakemake/src/snakemake/scheduling/milp.py": "9aacb871651eb8af3fe6e944fe37d3231ac2a1e6d2168830c43c291d2293de36",
+    "vendor/snakemake/src/snakemake/script/__init__.py": "5436e3e5f0761ce0550e9a8188e79bf7df7d004bdaf9e529ef74bbd5f5b8f305",
+    "vendor/snakemake/src/snakemake/settings/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/snakemake/src/snakemake/settings/enums.py": "2fe4468af2a5fa1863034652e2f018929eb22badebc2d45ef381c1069a4d1fd2",
+    "vendor/snakemake/src/snakemake/settings/types.py": "894b56d7ce1578842d6ee65924e9cf1e96792238382a096fa5fa896f7d14f3f8",
+    "vendor/snakemake/src/snakemake/shell.py": "f6f6507bcb6dc20c0e030091b79325c39d777d3b5330f32a50d56c9476555fc8",
+    "vendor/snakemake/src/snakemake/sourcecache.py": "9ebd0c5c53d2427354ea67956a1f95071930647f9dab35be453177bc0e7402d2",
+    "vendor/snakemake/src/snakemake/spawn_jobs.py": "75911b12d8dc7e2cbcb26cd9f041a6df655b786edd10eec0c2059a03aac79fe6",
+    "vendor/snakemake/src/snakemake/storage.py": "7c2ada6cf64fe0fe03d34e52cef27d8455a467ed1f98a9281f2547cebbdb4535",
+    "vendor/snakemake/src/snakemake/target_jobs.py": "38bb59c45f7795fc6a26c9e45ed84b9a28ed240523e866c160e1b2725acd9cd0",
+    "vendor/snakemake/src/snakemake/template_rendering/__init__.py": "a21bce75b0d2a75e0e065e3061875aaac8a247a30a7b4190f9a595571ef17af4",
+    "vendor/snakemake/src/snakemake/template_rendering/jinja2.py": "edde814fb9cfd8ff2c99daf8024732116a7f7e66554602fa77bc0fb5a082a864",
+    "vendor/snakemake/src/snakemake/template_rendering/yte.py": "9cede4909eb3ad34770e1142825d6e8a8e4ee835aa0864539c1b3e57dbb34e79",
+    "vendor/snakemake/src/snakemake/unit_tests/__init__.py": "ebb0a00323acd72fe5e658ccbc1420f7d45837a3588c4c6f648f65413252c54c",
+    "vendor/snakemake/src/snakemake/unit_tests/templates/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/snakemake/src/snakemake/unit_tests/templates/common.py.jinja2": "077ef829c73cbf6e685472c658a08009ff1b8d5870612e64748c989f6e106c41",
+    "vendor/snakemake/src/snakemake/unit_tests/templates/conftest.py.jinja2": "786936a4e7920d363d4665f4390a5545d1792a82bd737d178bf5346a40f31097",
+    "vendor/snakemake/src/snakemake/unit_tests/templates/ruletest.py.jinja2": "0b78589af540dd48ed953fa1e67f233518f614e7462dc71b9e2e0f7287aea799",
+    "vendor/snakemake/src/snakemake/utils.py": "ede2bd565dd8ab89ca8e2787924051c3d93075284a00bdd0e01e5c24d797d56c",
+    "vendor/snakemake/src/snakemake/workflow.py": "f97db48599fac5527c7655e5d48ef47d361b96575b8c0150d2e9fa7e4b0f7674",
+    "vendor/snakemake/src/snakemake/wrapper.py": "d680f10a05ddc43b7dd5e2e7018806afc10e4776dd823ace9ae5fdb3d9fa9797",
+    "vendor/snakemake/tests/test_touch/Snakefile": "cb8af73e418bad4c2b14105961ee1d4f264fea62fd6c0997e14007abdb3cb21d",
+    "vendor/snakemake/tests/test_touch/expected-results/test.out": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "workflow_probe.py": "7c6dd3234d21ebab70573f9365d3075929bf8651f82c753e5d0f31ccbc89aa09"
+  },
+  "mutable": [
+    "vendor/snakemake/src/snakemake/rules.py",
+    "vendor/snakemake/src/snakemake/jobs.py"
+  ],
+  "schema_version": "tbench.pristine_env_manifest.v1"
+}

tasks/candidate-0036-software-data-engineering/tests/fixtures/source_hashes.json

@@ -0,0 +1,13 @@
+{
+  "protected": {
+    "vendor/snakemake/src/snakemake/io/__init__.py": "5649e207cfc0327c0d6dc8f3b8abd96ff2785ae53bfdf2ac09a5675e4e89063b",
+    "vendor/snakemake/src/snakemake/iocontainers.py": "f48ce33373615ec8ea6885c0d8a57b1185c4628ff8f9c1b92081560437625bf6",
+    "vendor/snakemake/src/snakemake/workflow.py": "f97db48599fac5527c7655e5d48ef47d361b96575b8c0150d2e9fa7e4b0f7674",
+    "vendor/snakemake/pyproject.toml": "1937a29334f91bf13b3874e56a36cf352f9dff95a1946009e719d41f0875316a",
+    "vendor/snakemake/setup.py": "5c64dffbead198991a469f19799638f9254830c58a75137e65c85e7c334d6433"
+  },
+  "mutable_base": {
+    "vendor/snakemake/src/snakemake/rules.py": "3fa8657b9077ff76d1fb25c4fdab2d6a825d0330f4edb04dfb35b05723c509d0",
+    "vendor/snakemake/src/snakemake/jobs.py": "PLACEHOLDER"
+  }
+}

tasks/candidate-0036-software-data-engineering/tests/task_test.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+set -u
+mkdir -p /logs/verifier
+# tbench-anti-hack-guard:v1
+export PYTHONNOUSERSITE=1
+export PYTHONDONTWRITEBYTECODE=1
+# Fail open when the verifier image has no python3 (node-only tests images are
+# excluded from the RL set but still verifiable natively): a missing
+# interpreter must not swallow the grader's own reward write.
+if command -v python3 >/dev/null 2>&1 && [ -f /tests/anti_hack_guard.py ]; then
+  if ! python3 /tests/anti_hack_guard.py; then
+    # Guard already wrote reward=0; the reward file is the grading contract.
+    exit 0
+  fi
+fi
+
+
+python3 -m pytest --ctrf /logs/verifier/ctrf.json -q /tests/test_outputs.py
+status=$?
+if [ "$status" -eq 0 ]; then printf '1\n' > /logs/verifier/reward.txt; else printf '0\n' > /logs/verifier/reward.txt; fi
+exit "$status"

tasks/candidate-0036-software-data-engineering/tests/test.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Terminal-Bench grading: the task's own test script (task_test.sh here) writes /logs/verifier/reward.txt.
+# "-1" there is its crash sentinel: a testbed failure, so no reward is written (not scored).
+CWD=/app
+mkdir -p /logs/verifier
+# the task's anti-hack guard rejects files planted in the workspace: drop what agent harnesses leave there
+for d in .opencode .claude .codex .gemini .goose .aider.tags.cache.v4; do
+  grep -qx "$d" /var/lib/mimo/before 2>/dev/null || rm -rf "$CWD/$d"
+done
+cd "$CWD" && bash /tests/task_test.sh
+R=$(cat /logs/verifier/reward.txt 2>/dev/null | tr -d '[:space:]')
+if [ -z "$R" ] || [ "$R" = "-1" ]; then
+  rm -f /logs/verifier/reward.txt
+  echo "the tests crashed before grading (reward '${R}'): not scored" >&2
+  exit 1
+fi

tasks/candidate-0036-software-data-engineering/tests/test_outputs.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import subprocess
+from pathlib import Path
+
+APP = Path("/app")
+FIX = Path(__file__).parent / "fixtures"
+REPORT = APP / "output.json"
+RULES = APP / "vendor/snakemake/src/snakemake/rules.py"
+JOBS = APP / "vendor/snakemake/src/snakemake/jobs.py"
+
+
+def digest(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def parsed() -> dict:
+    assert REPORT.is_file()
+    value = json.loads(REPORT.read_text(encoding="utf-8"))
+    assert value["output_schema_version"] == "workflow-repair-1"
+    return value
+
+
+def test_gate_source_tree_and_report_contract() -> None:
+    hashes = json.loads((FIX / "source_hashes.json").read_text())
+    for rel, expected in hashes["protected"].items():
+        assert digest(APP / rel) == expected, rel
+    assert digest(RULES) != hashes["mutable_base"]["vendor/snakemake/src/snakemake/rules.py"]
+    assert "self.touch_output = set()" not in RULES.read_text()
+    assert "if f_ in self.rule.touch_output" not in JOBS.read_text()
+    value = parsed()
+    assert value["source_witness"]["both_mutable_modules_changed"] is True
+    assert value["aggregate"]["complete"] is True
+
+
+def test_core_independent_touch_and_wildcard_recompute() -> None:
+    value = parsed()
+    jobs = value["jobs"]
+    assert [j["wildcard"] for j in jobs] == ["alpha", "beta"]
+    for job in jobs:
+        expected = f"markers/{job['wildcard']}.ready"
+        assert job["touch_output"] == [expected]
+        assert job["outputs"][0]["path"] == expected
+        assert job["outputs"][0]["flags"] == ["touch"]
+
+
+def test_core_independent_non_touch_flags_recompute() -> None:
+    value = parsed()
+    for job in value["jobs"]:
+        name = job["wildcard"]
+        assert job["temp_output"] == [f"cache/{name}.bin"]
+        assert job["protected_output"] == [f"cache/{name}.bin"]
+        assert job["pipe_or_service_output"] == [f"streams/{name}.pipe"]
+        assert set(job["outputs"][1]["flags"]) == {"protected", "temp"}
+        assert set(job["outputs"][2]["flags"]) == {"pipe", "service"}
+
+
+def test_edge_constraint_and_downstream_replay() -> None:
+    value = parsed()
+    assert value["aggregate"] == {"complete": True, "targets": ["alpha", "beta"]}
+    assert all(j["downstream_complete"] for j in value["jobs"])
+    assert re.fullmatch(r"[a-z]+", "alpha") and not re.fullmatch(r"[a-z]+", "beta-2")
+    rerun = subprocess.run(["python3", str(APP / "workflow_probe.py")], cwd=APP, text=True, capture_output=True)
+    assert rerun.returncode == 0, rerun.stderr
+    assert parsed()["jobs"] == value["jobs"]
+
+
+def test_edge_all_categories_are_derived_from_expanded_item() -> None:
+    source = JOBS.read_text()
+    for flag in ("temp", "protected", "touch"):
+        assert f'is_flagged(f_, "{flag}")' in source
+    assert "is_flagged(f_, \"pipe\")" in source or 'is_flagged(f_, "service")' in source
+    rules = RULES.read_text()
+    assert "self.protected_output = set()" not in rules
+    assert "self.temp_output = set()" not in rules

tasks/candidate-0109-science-robotics/environment/Dockerfile

@@ -0,0 +1,3 @@
+# The task's image, pinned by digest (the same as [environment].docker_image).
+# Setup runs at start from [environment.healthcheck]; environment/setup/ is its readable copy.
+FROM docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:92e1760ed72a11016f8792e3f7c8ec97943ad4f16c591164e8d5d4e0b81c9ab5

tasks/candidate-0109-science-robotics/environment/setup/setup.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Runs once, as root, before the agent starts: Harbor's [environment.healthcheck] unpacks this folder into
+# /var/lib/mimo and runs it. Generated by mimo_harbor; see its README for how each step maps to Xiaomi's harness.
+M=/var/lib/mimo
+[ -f "$M/ready" ] && exit 0
+chmod 700 "$M"
+fail() { echo "setup: $*" >&2; exit 1; }
+# the answer-leak blocklist (mimoagent), applied to /etc/hosts by the agent right after it installs
+write_blocklist() { cp "$M/files/blocklist" "$M/blocklist"; }
+
+# Terminal-Bench rows (in the General domain): the Harbor convention itself. Scrub test leftovers from the image and
+# remember what was in the workspace, so harness residue can be told apart from the agent's work at grading time.
+rm -rf /tests
+find /logs/verifier -mindepth 1 -delete 2>/dev/null || true
+ls -A /app 2>/dev/null > "$M/before" || true
+
+touch "$M/ready"
+echo "setup done"

tasks/candidate-0109-science-robotics/instruction.md

@@ -0,0 +1,40 @@
+You are an agent, your current working directory is /app.
+
+You can use the tools available to you to interact with the computer to assist the user in completing tasks.
+
+# Repair numerical IK restart validation
+
+Work in the frozen source tree at `/app/vendor/robotics-toolbox-python`.
+
+The numerical inverse-kinematics solvers use random restarts when no explicit initial
+configuration is available. That restart operation exists in both the Python solver
+helper and the compiled ETS fast path. Models containing non-finite joint-limit
+metadata currently reach those samplers and fail inconsistently or contaminate the
+restart state.
+
+Repair the existing implementation with these requirements:
+
+1. Modify both `src/roboticstoolbox/robot/IK.py` and
+   `src/roboticstoolbox/ets/cpp-extensions/ik.cpp`; a one-backend repair is incomplete.
+2. Reject `NaN`, positive infinity, or negative infinity in any lower or upper joint
+   limit before consuming random-number state or producing a restart sample.
+3. Expose `ValueError` to Python callers. The diagnostic must identify joint-limit
+   validation and the offending joint index and values sufficiently to locate bad
+   robot metadata.
+4. Preserve existing valid behavior: seeded sampling remains deterministic, scalar
+   and batched requests retain shape `(count, joint_count)`, and every sample remains
+   inside its closed finite interval. Zero-width finite intervals remain valid.
+5. Do not clamp, replace, or invent finite limits, and do not bypass the native path,
+   replace the library with a standalone implementation, or modify tests to hide the
+   defect.
+
+After repairing the source, run the offline integration check:
+
+```sh
+cd /app/vendor/robotics-toolbox-python
+python3 /app/tools/run_validation.py > /app/output.json
+```
+
+The command must succeed and produce `/app/output.json` with schema version
+`robotics.ik_restart_validation.v1`. Network access and package installation are not
+available.

tasks/candidate-0109-science-robotics/task.toml

@@ -0,0 +1,39 @@
+schema_version = "1.4"
+
+[task]
+name = "mimo-v2.6-rl/candidate-0109-science-robotics"
+description = "MiMo-V2.6-RL terminal task candidate-0109-science-robotics"
+keywords = ["mimo-v2.6-rl", "terminal"]
+
+[metadata]
+adapter = "mimo_harbor 1.0.0"
+domain = "terminal"
+original_allow_internet = false
+reference_harness = "XiaomiMiMo/verl a2ad9f6 + XiaomiMiMo/mimoagent 467f0a1"
+reference_step_limit = 500
+source_dataset = "XiaomiMiMo/MiMo-V2.6-RL-oss"
+source_id = "candidate-0109-science-robotics"
+source_revision = "639865fd3374018d6cb29b9fb82dd531406fcf5f"
+
+[agent]
+timeout_sec = 900.0
+
+[verifier]
+timeout_sec = 240.0
+user = "root"
+
+[environment]
+docker_image = "docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:92e1760ed72a11016f8792e3f7c8ec97943ad4f16c591164e8d5d4e0b81c9ab5"
+workdir = "/app"
+cpus = 1
+memory_mb = 2048
+storage_mb = 10240
+network_mode = "public"
+build_timeout_sec = 1800.0
+
+[environment.healthcheck]
+# one-time setup before the agent (environment/setup/setup.sh)
+command = "bash -c 'test -f /var/lib/mimo/ready || { mkdir -p /var/lib/mimo && echo H4sIAAAAAAAC/+2T30/UQBDH77l/xddCEAx3PVAhgUiCkegLL+iDCSFk206vm9vuNrvbq0T83532gJP4qr44n5e2+2PmO9+ZBopdOwv15C8yZ47n8/E5//158Pbo8PH9Yf34zeujCeaTf0AXovKccvJ/svUiy7XNchXqZAtXnQ1wtqB9qADvXNxHTpXzhFgT1IJsxGBYDCf4pHzu/MuAa7Ir7Z1teHdWkzKxLmoqljfobKuKZeDLOqBypiQPbaPjVNlK+czoPGt046BsCT8k13GGj2TJq0gl8jsM27f1mOoUgYhPBFxdnH+4vOCIHrXrQaqoWRa1aFTL2Ry+auUazdr4pqUQZsnlu2cZk2tMK6Tbl5knVd6luMHODuibjpgnRd24Ejyyw4E0qZQ2u3v4DipqhzQMv8wJtl+lONs5PF1fOjjFD65qdMmGnvzUkFoiN65YGh0idoeso4F7bG7bGs31sdKMYpHVLnBVXO3GZa8XdYSq4mBZZNfYdmNC0nsd6fYp7qiraMdKKm0oZE9b6bi4+RwUssQv5BttlZm+J8u2edcH7Go7pl47b1C6Rmm7dzIurvuMwtkVC9PODi0gU83wufBdjkhcnqEquhV5brN3zXhPN1zJ0FlO6qmhJudS+lpF9DxcDxl755eBh4QnLrjHbvHxoMuOUCjL88c2mZI947HbRB9d4gYPAcAxF16V2i4QdUOzxDeY+grZoC0klebxyoxbhIwl6kqzkCmbUFIbaxxgWpKhSDg8y0paZbYzBvf3iL6jxARMz5Fxx55tn63NHf+N9OlwEl3Hnm7GKvllZNhVS2kyEQRBEARBEARBEARBEARBEARBEARBEARBEIQ/xk8LxjaZACgAAA== | base64 -d | tar -xzf - -C /var/lib/mimo && bash /var/lib/mimo/setup.sh; }'"
+timeout_sec = 1200.0
+retries = 0
+interval_sec = 5.0

tasks/candidate-0109-science-robotics/tests/anti_hack_guard.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""TBench in-pod anti-hack guard.
+
+Runs at the very start of ``tests/test.sh``, inside the verifier container,
+after the agent's ``/app`` has been copied in.  The RL harness materialises
+``tests/`` into the MAIN container only after the agent exits, so the agent
+cannot see or tamper with this file — which makes it the right place to reject
+workspace pollution the agent planted during the episode.
+
+Detection (any hit -> write reward=0 and exit non-zero):
+
+1. **Planted interpreter hooks.**  ``conftest.py`` / ``sitecustomize.py`` /
+   ``usercustomize.py`` / ``*.pth`` / ``pytest.ini`` / ``.coveragerc`` /
+   ``tox.ini`` anywhere under ``/app`` whose path is NOT listed in the pristine
+   manifest.  Upstream vendor trees that legitimately ship a ``conftest.py``
+   are listed in the manifest and are therefore not false positives.
+2. **Protected-file mutation.**  Any manifest entry whose sha256 changed while
+   its path is outside the declared mutable set.
+3. **Protected-file deletion.**  Any non-mutable, non-artifact manifest entry
+   that vanished.
+
+The manifest is generated from the pristine ``environment/`` tree and shipped
+as ``tests/fixtures/pristine_env_manifest.json``.  A missing manifest degrades to
+name-only detection so the guard never blocks an uninstrumented task.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+SCHEMA = "tbench.pristine_env_manifest.v1"
+
+APP = Path(os.environ.get("TBENCH_APP_ROOT", "/app"))
+FIXTURES = Path(os.environ.get("TBENCH_FIXTURES", "/tests/fixtures"))
+MANIFEST = FIXTURES / "pristine_env_manifest.json"
+REWARD = Path(os.environ.get("TBENCH_REWARD_FILE", "/logs/verifier/reward.txt"))
+
+DANGEROUS_NAMES = {
+    "conftest.py",
+    "sitecustomize.py",
+    "usercustomize.py",
+    "pytest.ini",
+    ".coveragerc",
+    "tox.ini",
+    "pyproject.toml",  # only dangerous when planted; upstream copies are in the manifest
+}
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def is_dangerous(rel: str) -> bool:
+    name = rel.rsplit("/", 1)[-1]
+    return name in DANGEROUS_NAMES or name.endswith(".pth")
+
+
+def load_manifest() -> dict | None:
+    if not MANIFEST.is_file():
+        return None
+    try:
+        doc = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(doc, dict) or not isinstance(doc.get("files"), dict):
+        return None
+    return doc
+
+
+def reject(reason: str, reward: Path | None = None) -> int:
+    target = REWARD if reward is None else reward
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text("0\n", encoding="utf-8")
+    except OSError as exc:  # pragma: no cover - reward file is the contract
+        print(f"anti_hack_guard: cannot write reward file: {exc}", file=sys.stderr)
+        return 2
+    print(f"anti_hack_guard: REJECT {reason}", file=sys.stderr)
+    return 1
+
+
+def scan(manifest: dict | None, app: Path | None = None) -> str | None:
+    app_root = APP if app is None else app
+    files: dict[str, str] = (manifest or {}).get("files") or {}
+    mutable_set = {
+        entry.lstrip("/")
+        for entry in (manifest or {}).get("mutable") or []
+        if isinstance(entry, str)
+    }
+    artifacts = {
+        str(entry).removeprefix("/app/").lstrip("/")
+        for entry in (manifest or {}).get("artifacts") or []
+        if isinstance(entry, str)
+    }
+
+    if not app_root.is_dir():
+        return None
+
+    for path in sorted(app_root.rglob("*")):
+        if not path.is_file() or path.is_symlink():
+            continue
+        rel = path.relative_to(app_root).as_posix()
+        if is_dangerous(rel) and rel not in files:
+            return f"planted_interpreter_hook:{rel}"
+
+    if manifest is None:
+        return None
+
+    # Deletion detection is only sound when the built image is known to equal
+    # the source tree (plain ``COPY . /app``).  A multi-stage or dockerignored
+    # build legitimately omits files, and rejecting those would zero out the
+    # oracle for a perfectly good task.
+    detect_deletion = bool(manifest.get("detect_deletion", True))
+    for rel, expected in files.items():
+        if rel in mutable_set or rel in artifacts:
+            continue
+        path = app_root / rel
+        if not path.exists():
+            if detect_deletion:
+                return f"protected_file_deleted:{rel}"
+            continue
+        if not path.is_file():
+            continue
+        if sha256(path) != expected:
+            return f"protected_file_mutated:{rel}"
+    return None
+
+
+def main(app: Path | None = None, reward: Path | None = None) -> int:
+    manifest = load_manifest()
+    reason = scan(manifest, app=app)
+    if reason:
+        return reject(reason, reward=reward)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tasks/candidate-0109-science-robotics/tests/fixtures/immutable_hashes.json

@@ -0,0 +1,10 @@
+{
+  "tools/native_restart_probe.cpp": "7009f33704adf07add9be95b609798c55b604465e1d9c016efc944be6ee8ad37",
+  "tools/run_validation.py": "5f47f9abab08cc201b2aa3e5b3988e8f49226354a02994217e7aebe15267907f",
+  "vendor/robotics-toolbox-python/CMakeLists.txt": "a94f9ae5b051e6ba0e11ace1097267316b7bf6b0ae87eb77bad09cfdffd7854f",
+  "vendor/robotics-toolbox-python/pyproject.toml": "c63a4d232bd3f0debcf9db16abf37399c72dea5e3e11a0e96c9a0ef9fab64859",
+  "vendor/robotics-toolbox-python/src/roboticstoolbox/ets/cpp-extensions/fknm_nb.cpp": "65e9edec9a7d827f8283a6369d99eb81a68cc22f9606b67db40b97135c9bcf80",
+  "vendor/robotics-toolbox-python/src/roboticstoolbox/ets/cpp-extensions/ik.h": "3a4813809e2d57c3f8ede9674023a733bea7f2bbb43e99193c24059949fb7d66",
+  "vendor/robotics-toolbox-python/src/roboticstoolbox/ets/cpp-extensions/methods.h": "0d11b0ae902a487b3b746d209a30ef8670e6fe1b03f6b0be63e925c9fcb41030",
+  "vendor/robotics-toolbox-python/src/roboticstoolbox/ets/cpp-extensions/structs.h": "23c18ed2aec9399f96c8dbfb304615de736c0b7dd3dd522408d621def4b69e52"
+}

tasks/candidate-0109-science-robotics/tests/fixtures/native_guard_probe.cpp

@@ -0,0 +1,69 @@
+#include <cmath>
+#include <cstdlib>
+#include <iostream>
+#include <limits>
+#include <stdexcept>
+#include <string>
+
+#include <Eigen/Dense>
+
+using VectorX = Eigen::VectorXd;
+using MapVectorX = Eigen::Map<Eigen::VectorXd>;
+
+struct ETS {
+    int n;
+    double *qlim_l;
+    double *qlim_h;
+    double *q_range2;
+};
+
+// __RAND_Q_FUNCTION__
+
+static bool reject_case(ETS *ets, MapVectorX q, int expected_joint) {
+    std::srand(701);
+    const int expected_next = std::rand();
+    std::srand(701);
+    try {
+        _rand_q(ets, q);
+    } catch (const std::invalid_argument &error) {
+        const std::string message(error.what());
+        const int observed_next = std::rand();
+        return observed_next == expected_next &&
+               message.find("joint") != std::string::npos &&
+               message.find(std::to_string(expected_joint)) != std::string::npos &&
+               message.find("finite") != std::string::npos;
+    }
+    return false;
+}
+
+int main() {
+    ETS ets{};
+    ets.n = 4;
+    double lower[4] = {-2.0, 0.5, -3.0, 6.0};
+    double upper[4] = {1.0, 0.5, 5.0, 9.0};
+    double half_range[4] = {1.5, 0.0, 4.0, 1.5};
+    double output[4] = {};
+    ets.qlim_l = lower;
+    ets.qlim_h = upper;
+    ets.q_range2 = half_range;
+    MapVectorX q(output, 4);
+
+    std::srand(313);
+    _rand_q(&ets, q);
+    if (!q.allFinite()) return 10;
+    for (int joint = 0; joint < ets.n; ++joint)
+        if (q(joint) < lower[joint] || q(joint) > upper[joint]) return 11;
+    if (q(1) != 0.5) return 12;
+
+    lower[2] = std::numeric_limits<double>::infinity();
+    if (!reject_case(&ets, q, 2)) return 20;
+    lower[2] = -3.0;
+    upper[3] = -std::numeric_limits<double>::infinity();
+    if (!reject_case(&ets, q, 3)) return 21;
+    upper[3] = 9.0;
+    upper[1] = std::numeric_limits<double>::quiet_NaN();
+    if (!reject_case(&ets, q, 1)) return 22;
+
+    std::cout << "native-guard-ok\n";
+    return 0;
+}

tasks/candidate-0109-science-robotics/tests/task_test.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+set -eu
+mkdir -p /logs/verifier
+set +e
+# tbench-anti-hack-guard:v1
+export PYTHONNOUSERSITE=1
+export PYTHONDONTWRITEBYTECODE=1
+# Fail open when the verifier image has no python3 (node-only tests images are
+# excluded from the RL set but still verifiable natively): a missing
+# interpreter must not swallow the grader's own reward write.
+if command -v python3 >/dev/null 2>&1 && [ -f /tests/anti_hack_guard.py ]; then
+  if ! python3 /tests/anti_hack_guard.py; then
+    # Guard already wrote reward=0; the reward file is the grading contract.
+    exit 0
+  fi
+fi
+
+
+python3 -m pytest --confcutdir=/tests --ctrf /logs/verifier/ctrf.json -q /tests/test_outputs.py
+status=$?
+set -e
+if [ "$status" -eq 0 ]; then
+    printf '1\n' > /logs/verifier/reward.txt
+else
+    printf '0\n' > /logs/verifier/reward.txt
+fi
+exit 0

tasks/candidate-0109-science-robotics/tests/test.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Terminal-Bench grading: the task's own test script (task_test.sh here) writes /logs/verifier/reward.txt.
+# "-1" there is its crash sentinel: a testbed failure, so no reward is written (not scored).
+CWD=/app
+mkdir -p /logs/verifier
+# the task's anti-hack guard rejects files planted in the workspace: drop what agent harnesses leave there
+for d in .opencode .claude .codex .gemini .goose .aider.tags.cache.v4; do
+  grep -qx "$d" /var/lib/mimo/before 2>/dev/null || rm -rf "$CWD/$d"
+done
+cd "$CWD" && bash /tests/task_test.sh
+R=$(cat /logs/verifier/reward.txt 2>/dev/null | tr -d '[:space:]')
+if [ -z "$R" ] || [ "$R" = "-1" ]; then
+  rm -f /logs/verifier/reward.txt
+  echo "the tests crashed before grading (reward '${R}'): not scored" >&2
+  exit 1
+fi

tasks/candidate-0109-science-robotics/tests/test_outputs.py

@@ -0,0 +1,231 @@
+import ast
+from functools import lru_cache
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import shlex
+import subprocess
+import tempfile
+import types
+
+import numpy as np
+
+
+APP = Path(os.environ.get("TBENCH_APP_ROOT", "/app"))
+TEST_ROOT = Path(os.environ.get("TBENCH_TEST_ROOT", "/tests"))
+PROJECT = APP / "vendor/robotics-toolbox-python"
+IK_PATH = PROJECT / "src/roboticstoolbox/robot/IK.py"
+CPP_PATH = PROJECT / "src/roboticstoolbox/ets/cpp-extensions/ik.cpp"
+ARTIFACT = APP / "output.json"
+
+
+@lru_cache(maxsize=1)
+def load_solver_class():
+    tree = ast.parse(IK_PATH.read_text())
+    solver = next(
+        node
+        for node in tree.body
+        if isinstance(node, ast.ClassDef) and node.name == "IKSolver"
+    )
+    imports = [
+        ast.parse("import numpy as np").body[0],
+        ast.parse("from abc import ABC, abstractmethod").body[0],
+    ]
+    namespace = {
+        "__name__": "submitted_ik",
+        "rtb": types.SimpleNamespace(),
+        "SE3": object,
+        "IKSolution": object,
+        "Tuple": tuple,
+        "cast": lambda _, value: value,
+        "ArrayLike": object,
+        "NDArray": np.ndarray,
+    }
+    exec(
+        compile(
+            ast.Module(body=imports + [solver], type_ignores=[]),
+            str(IK_PATH),
+            "exec",
+        ),
+        namespace,
+    )
+    solver_class = namespace["IKSolver"]
+    solver_class.__abstractmethods__ = frozenset()
+    return solver_class
+
+
+class CountingRng:
+    def __init__(self, seed):
+        self.generator = np.random.default_rng(seed)
+        self.calls = 0
+
+    def uniform(self, *args, **kwargs):
+        self.calls += 1
+        return self.generator.uniform(*args, **kwargs)
+
+
+def sha256(path):
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def submitted_rand_q_source():
+    source = CPP_PATH.read_text()
+    signature = "void _rand_q("
+    start = source.index(signature)
+    opening = source.index("{", start)
+    depth = 0
+    for index in range(opening, len(source)):
+        if source[index] == "{":
+            depth += 1
+        elif source[index] == "}":
+            depth -= 1
+            if depth == 0:
+                return source[start : index + 1]
+    raise AssertionError("unable to isolate submitted _rand_q definition")
+
+
+def test_gate_artifact_schema_and_hashes():
+    assert ARTIFACT.is_file()
+    data = json.loads(ARTIFACT.read_text())
+    assert data["schema_version"] == "robotics.ik_restart_validation.v1"
+    assert set(data) == {"schema_version", "python", "native_cpp", "source_sha256"}
+    assert data["source_sha256"] == {
+        "src/roboticstoolbox/robot/IK.py": sha256(IK_PATH),
+        "src/roboticstoolbox/ets/cpp-extensions/ik.cpp": sha256(CPP_PATH),
+    }
+
+
+def test_gate_protected_source_assets():
+    expected = json.loads((TEST_ROOT / "fixtures/immutable_hashes.json").read_text())
+    for relative, digest in expected.items():
+        path = APP / relative
+        assert path.is_file(), relative
+        assert sha256(path) == digest, relative
+
+
+def test_core_python_seeded_sampling_matches_independent_recompute():
+    solver_class = load_solver_class()
+    solver = object.__new__(solver_class)
+    solver._private_random = CountingRng(9137)
+    qlim = np.array([[-2.5, 0.125, 4.0, -8.0], [1.5, 0.125, 9.0, -3.0]])
+    ets = types.SimpleNamespace(n=4, qlim=qlim)
+    actual = solver._random_q(ets, 11)
+
+    reference_rng = np.random.default_rng(9137)
+    expected = np.zeros((11, 4))
+    for row in range(11):
+        for joint in range(4):
+            expected[row, joint] = reference_rng.uniform(
+                qlim[0, joint], qlim[1, joint]
+            )
+
+    assert actual.shape == (11, 4)
+    assert np.isfinite(actual).all()
+    assert np.all(actual >= qlim[0]) and np.all(actual <= qlim[1])
+    assert np.all(actual[:, 1] == 0.125)
+    assert np.allclose(actual, expected, rtol=0.0, atol=1e-14)
+
+
+def test_core_python_rejects_all_nonfinite_endpoints_before_rng():
+    solver_class = load_solver_class()
+    cases = [
+        (np.array([[-1.0, math.inf], [1.0, 2.0]]), "1"),
+        (np.array([[-math.inf, 0.0], [1.0, 2.0]]), "0"),
+        (np.array([[-1.0, 0.0], [math.nan, 2.0]]), "0"),
+    ]
+    for qlim, joint_text in cases:
+        solver = object.__new__(solver_class)
+        solver._private_random = CountingRng(44)
+        ets = types.SimpleNamespace(n=2, qlim=qlim)
+        try:
+            solver._random_q(ets, 5)
+        except ValueError as error:
+            message = str(error).lower()
+            assert "joint" in message
+            assert "limit" in message
+            assert "finite" in message
+            assert joint_text in message
+        else:
+            raise AssertionError("non-finite qlim was accepted")
+        assert solver._private_random.calls == 0
+
+
+def test_core_native_cpp_sampler_compiles_and_runs():
+    fixture = TEST_ROOT / "fixtures/native_guard_probe.cpp"
+    with tempfile.TemporaryDirectory(prefix="native-ik-verifier-") as directory:
+        directory_path = Path(directory)
+        executable = directory_path / "native_guard_probe"
+        marker = "// __RAND_Q_FUNCTION__"
+        template = fixture.read_text()
+        assert marker in template
+        generated_source = directory_path / "native_guard_probe.cpp"
+        generated_source.write_text(
+            template.replace(marker, submitted_rand_q_source(), 1)
+        )
+        includes = shlex.split(
+            subprocess.check_output(["python3-config", "--includes"], text=True)
+        )
+        ldflags = shlex.split(
+            subprocess.check_output(
+                ["python3-config", "--embed", "--ldflags"], text=True
+            )
+        )
+        command = [
+            os.environ.get("CXX", "g++"),
+            "-std=c++17",
+            "-O0",
+            "-ffunction-sections",
+            "-fdata-sections",
+            f"-I{PROJECT / 'src/roboticstoolbox/ets/cpp-extensions'}",
+            *includes,
+            str(generated_source),
+            "-Wl,--gc-sections",
+            *ldflags,
+            "-o",
+            str(executable),
+        ]
+        subprocess.run(command, cwd=PROJECT, check=True, timeout=90)
+        result = subprocess.run(
+            [str(executable)], check=True, capture_output=True, text=True, timeout=15
+        )
+        assert result.stdout.strip() == "native-guard-ok"
+
+
+def test_edge_multiple_invalid_python_joints_are_diagnostic():
+    solver_class = load_solver_class()
+    solver = object.__new__(solver_class)
+    solver._private_random = CountingRng(7)
+    ets = types.SimpleNamespace(
+        n=4,
+        qlim=np.array(
+            [[-1.0, -math.inf, 2.0, 3.0], [1.0, 4.0, math.nan, math.inf]]
+        ),
+    )
+    try:
+        solver._random_q(ets, 1)
+    except ValueError as error:
+        message = str(error).lower()
+        assert "1" in message and "2" in message and "3" in message
+        assert "inf" in message and "nan" in message
+    else:
+        raise AssertionError("multiple invalid joints were accepted")
+    assert solver._private_random.calls == 0
+
+
+def test_edge_artifact_reports_executed_integration_results():
+    data = json.loads(ARTIFACT.read_text())
+    assert data["python"] == {
+        "shape": [9, 3],
+        "finite": True,
+        "bounded": True,
+        "zero_width_preserved": True,
+        "invalid_rejected_before_rng": True,
+    }
+    assert data["native_cpp"] == {
+        "finite": True,
+        "bounded": True,
+        "zero_width": True,
+        "invalid_rejected_before_rng": True,
+    }

tasks/candidate-0260-security-appsec/environment/Dockerfile

@@ -0,0 +1,3 @@
+# The task's image, pinned by digest (the same as [environment].docker_image).
+# Setup runs at start from [environment.healthcheck]; environment/setup/ is its readable copy.
+FROM docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:22f5efb3150202c6e0894f9838c064c2a88e758bd9d4e62d795ad95d9986913a

tasks/candidate-0260-security-appsec/environment/setup/setup.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Runs once, as root, before the agent starts: Harbor's [environment.healthcheck] unpacks this folder into
+# /var/lib/mimo and runs it. Generated by mimo_harbor; see its README for how each step maps to Xiaomi's harness.
+M=/var/lib/mimo
+[ -f "$M/ready" ] && exit 0
+chmod 700 "$M"
+fail() { echo "setup: $*" >&2; exit 1; }
+# the answer-leak blocklist (mimoagent), applied to /etc/hosts by the agent right after it installs
+write_blocklist() { cp "$M/files/blocklist" "$M/blocklist"; }
+
+# Terminal-Bench rows (in the General domain): the Harbor convention itself. Scrub test leftovers from the image and
+# remember what was in the workspace, so harness residue can be told apart from the agent's work at grading time.
+rm -rf /tests
+find /logs/verifier -mindepth 1 -delete 2>/dev/null || true
+ls -A /app 2>/dev/null > "$M/before" || true
+
+touch "$M/ready"
+echo "setup done"

tasks/candidate-0260-security-appsec/instruction.md

@@ -0,0 +1,30 @@
+You are an agent, your current working directory is /app.
+
+You can use the tools available to you to interact with the computer to assist the user in completing tasks.
+
+# Repair the offline security scan pipeline
+
+You are given a vendored Bandit source tree under `/app/vendor/pycqa-bandit` and
+an offline fixture set under `/app/workload/fixtures`. Repair the existing source
+so the normal file-level Trojan Source check can be used by an integration
+caller, then produce `/app/output.json` by running the supplied scan entrypoint.
+Do not replace the scanner with a new standalone evaluator.
+
+The producer must preserve the scanner's security semantics:
+
+- bidirectional Unicode controls are reported as B613 with HIGH severity and
+  MEDIUM confidence;
+- the finding location is 1-based and points to the physical source line and
+  character column containing the control character;
+- file-level plugins may provide their own non-empty `linerange`; generic tester
+  enrichment must not erase it, while issues without a custom range still get
+  the framework context range;
+- filename and original file bytes remain attached to each issue, and the
+  non-UTF-8 fixture must be decoded according to its Python encoding declaration;
+- clean files must remain clean.
+
+Use the existing modules and integration path. The output contract is documented
+in `/app/CONTRACT.md`; its schema version must be exactly
+`bandit_trojan_repair.v1`. Include every `*.py` fixture in lexical filename order,
+including clean files, and use the supplied `/app/run_scan.py` after repairing
+the source. Keep the workspace offline and do not add dependencies.

tasks/candidate-0260-security-appsec/task.toml

@@ -0,0 +1,39 @@
+schema_version = "1.4"
+
+[task]
+name = "mimo-v2.6-rl/candidate-0260-security-appsec"
+description = "MiMo-V2.6-RL terminal task candidate-0260-security-appsec"
+keywords = ["mimo-v2.6-rl", "terminal"]
+
+[metadata]
+adapter = "mimo_harbor 1.0.0"
+domain = "terminal"
+original_allow_internet = false
+reference_harness = "XiaomiMiMo/verl a2ad9f6 + XiaomiMiMo/mimoagent 467f0a1"
+reference_step_limit = 500
+source_dataset = "XiaomiMiMo/MiMo-V2.6-RL-oss"
+source_id = "candidate-0260-security-appsec"
+source_revision = "639865fd3374018d6cb29b9fb82dd531406fcf5f"
+
+[agent]
+timeout_sec = 900.0
+
+[verifier]
+timeout_sec = 240.0
+user = "root"
+
+[environment]
+docker_image = "docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:22f5efb3150202c6e0894f9838c064c2a88e758bd9d4e62d795ad95d9986913a"
+workdir = "/app"
+cpus = 1
+memory_mb = 2048
+storage_mb = 10240
+network_mode = "public"
+build_timeout_sec = 1800.0
+
+[environment.healthcheck]
+# one-time setup before the agent (environment/setup/setup.sh)
+command = "bash -c 'test -f /var/lib/mimo/ready || { mkdir -p /var/lib/mimo && echo H4sIAAAAAAAC/+2T30/UQBDH77l/xddCEAx3PVAhgUiCkegLL+iDCSFk206vm9vuNrvbq0T83532gJP4qr44n5e2+2PmO9+ZBopdOwv15C8yZ47n8/E5//158Pbo8PH9Yf34zeujCeaTf0AXovKccvJ/svUiy7XNchXqZAtXnQ1wtqB9qADvXNxHTpXzhFgT1IJsxGBYDCf4pHzu/MuAa7Ir7Z1teHdWkzKxLmoqljfobKuKZeDLOqBypiQPbaPjVNlK+czoPGt046BsCT8k13GGj2TJq0gl8jsM27f1mOoUgYhPBFxdnH+4vOCIHrXrQaqoWRa1aFTL2Ry+auUazdr4pqUQZsnlu2cZk2tMK6Tbl5knVd6luMHODuibjpgnRd24Ejyyw4E0qZQ2u3v4DipqhzQMv8wJtl+lONs5PF1fOjjFD65qdMmGnvzUkFoiN65YGh0idoeso4F7bG7bGs31sdKMYpHVLnBVXO3GZa8XdYSq4mBZZNfYdmNC0nsd6fYp7qiraMdKKm0oZE9b6bi4+RwUssQv5BttlZm+J8u2edcH7Go7pl47b1C6Rmm7dzIurvuMwtkVC9PODi0gU83wufBdjkhcnqEquhV5brN3zXhPN1zJ0FlO6qmhJudS+lpF9DxcDxl755eBh4QnLrjHbvHxoMuOUCjL88c2mZI947HbRB9d4gYPAcAxF16V2i4QdUOzxDeY+grZoC0klebxyoxbhIwl6kqzkCmbUFIbaxxgWpKhSDg8y0paZbYzBvf3iL6jxARMz5Fxx55tn63NHf+N9OlwEl3Hnm7GKvllZNhVS2kyEQRBEARBEARBEARBEARBEARBEARBEARBEIQ/xk8LxjaZACgAAA== | base64 -d | tar -xzf - -C /var/lib/mimo && bash /var/lib/mimo/setup.sh; }'"
+timeout_sec = 1200.0
+retries = 0
+interval_sec = 5.0

tasks/candidate-0260-security-appsec/tests/anti_hack_guard.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""TBench in-pod anti-hack guard.
+
+Runs at the very start of ``tests/test.sh``, inside the verifier container,
+after the agent's ``/app`` has been copied in.  The RL harness materialises
+``tests/`` into the MAIN container only after the agent exits, so the agent
+cannot see or tamper with this file — which makes it the right place to reject
+workspace pollution the agent planted during the episode.
+
+Detection (any hit -> write reward=0 and exit non-zero):
+
+1. **Planted interpreter hooks.**  ``conftest.py`` / ``sitecustomize.py`` /
+   ``usercustomize.py`` / ``*.pth`` / ``pytest.ini`` / ``.coveragerc`` /
+   ``tox.ini`` anywhere under ``/app`` whose path is NOT listed in the pristine
+   manifest.  Upstream vendor trees that legitimately ship a ``conftest.py``
+   are listed in the manifest and are therefore not false positives.
+2. **Protected-file mutation.**  Any manifest entry whose sha256 changed while
+   its path is outside the declared mutable set.
+3. **Protected-file deletion.**  Any non-mutable, non-artifact manifest entry
+   that vanished.
+
+The manifest is generated from the pristine ``environment/`` tree and shipped
+as ``tests/fixtures/pristine_env_manifest.json``.  A missing manifest degrades to
+name-only detection so the guard never blocks an uninstrumented task.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+SCHEMA = "tbench.pristine_env_manifest.v1"
+
+APP = Path(os.environ.get("TBENCH_APP_ROOT", "/app"))
+FIXTURES = Path(os.environ.get("TBENCH_FIXTURES", "/tests/fixtures"))
+MANIFEST = FIXTURES / "pristine_env_manifest.json"
+REWARD = Path(os.environ.get("TBENCH_REWARD_FILE", "/logs/verifier/reward.txt"))
+
+DANGEROUS_NAMES = {
+    "conftest.py",
+    "sitecustomize.py",
+    "usercustomize.py",
+    "pytest.ini",
+    ".coveragerc",
+    "tox.ini",
+    "pyproject.toml",  # only dangerous when planted; upstream copies are in the manifest
+}
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def is_dangerous(rel: str) -> bool:
+    name = rel.rsplit("/", 1)[-1]
+    return name in DANGEROUS_NAMES or name.endswith(".pth")
+
+
+def load_manifest() -> dict | None:
+    if not MANIFEST.is_file():
+        return None
+    try:
+        doc = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(doc, dict) or not isinstance(doc.get("files"), dict):
+        return None
+    return doc
+
+
+def reject(reason: str, reward: Path | None = None) -> int:
+    target = REWARD if reward is None else reward
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text("0\n", encoding="utf-8")
+    except OSError as exc:  # pragma: no cover - reward file is the contract
+        print(f"anti_hack_guard: cannot write reward file: {exc}", file=sys.stderr)
+        return 2
+    print(f"anti_hack_guard: REJECT {reason}", file=sys.stderr)
+    return 1
+
+
+def scan(manifest: dict | None, app: Path | None = None) -> str | None:
+    app_root = APP if app is None else app
+    files: dict[str, str] = (manifest or {}).get("files") or {}
+    mutable_set = {
+        entry.lstrip("/")
+        for entry in (manifest or {}).get("mutable") or []
+        if isinstance(entry, str)
+    }
+    artifacts = {
+        str(entry).removeprefix("/app/").lstrip("/")
+        for entry in (manifest or {}).get("artifacts") or []
+        if isinstance(entry, str)
+    }
+
+    if not app_root.is_dir():
+        return None
+
+    for path in sorted(app_root.rglob("*")):
+        if not path.is_file() or path.is_symlink():
+            continue
+        rel = path.relative_to(app_root).as_posix()
+        if is_dangerous(rel) and rel not in files:
+            return f"planted_interpreter_hook:{rel}"
+
+    if manifest is None:
+        return None
+
+    # Deletion detection is only sound when the built image is known to equal
+    # the source tree (plain ``COPY . /app``).  A multi-stage or dockerignored
+    # build legitimately omits files, and rejecting those would zero out the
+    # oracle for a perfectly good task.
+    detect_deletion = bool(manifest.get("detect_deletion", True))
+    for rel, expected in files.items():
+        if rel in mutable_set or rel in artifacts:
+            continue
+        path = app_root / rel
+        if not path.exists():
+            if detect_deletion:
+                return f"protected_file_deleted:{rel}"
+            continue
+        if not path.is_file():
+            continue
+        if sha256(path) != expected:
+            return f"protected_file_mutated:{rel}"
+    return None
+
+
+def main(app: Path | None = None, reward: Path | None = None) -> int:
+    manifest = load_manifest()
+    reason = scan(manifest, app=app)
+    if reason:
+        return reject(reason, reward=reward)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tasks/candidate-0260-security-appsec/tests/fixtures/clean_issue.py

@@ -0,0 +1,244 @@
+#
+# Copyright 2015 Hewlett-Packard Development Company, L.P.
+#
+# SPDX-License-Identifier: Apache-2.0
+import linecache
+
+from bandit.core import constants
+
+
+class Cwe:
+    NOTSET = 0
+    IMPROPER_INPUT_VALIDATION = 20
+    PATH_TRAVERSAL = 22
+    OS_COMMAND_INJECTION = 78
+    XSS = 79
+    BASIC_XSS = 80
+    SQL_INJECTION = 89
+    CODE_INJECTION = 94
+    IMPROPER_WILDCARD_NEUTRALIZATION = 155
+    HARD_CODED_PASSWORD = 259
+    IMPROPER_ACCESS_CONTROL = 284
+    IMPROPER_CERT_VALIDATION = 295
+    CLEARTEXT_TRANSMISSION = 319
+    INADEQUATE_ENCRYPTION_STRENGTH = 326
+    BROKEN_CRYPTO = 327
+    INSUFFICIENT_RANDOM_VALUES = 330
+    INSECURE_TEMP_FILE = 377
+    UNCONTROLLED_RESOURCE_CONSUMPTION = 400
+    DESERIALIZATION_OF_UNTRUSTED_DATA = 502
+    MULTIPLE_BINDS = 605
+    IMPROPER_CHECK_OF_EXCEPT_COND = 703
+    INCORRECT_PERMISSION_ASSIGNMENT = 732
+    INAPPROPRIATE_ENCODING_FOR_OUTPUT_CONTEXT = 838
+
+    MITRE_URL_PATTERN = "https://cwe.mitre.org/data/definitions/%s.html"
+
+    def __init__(self, id=NOTSET):
+        self.id = id
+
+    def link(self):
+        if self.id == Cwe.NOTSET:
+            return ""
+
+        return Cwe.MITRE_URL_PATTERN % str(self.id)
+
+    def __str__(self):
+        if self.id == Cwe.NOTSET:
+            return ""
+
+        return "CWE-%i (%s)" % (self.id, self.link())
+
+    def as_dict(self):
+        return (
+            {"id": self.id, "link": self.link()}
+            if self.id != Cwe.NOTSET
+            else {}
+        )
+
+    def as_jsons(self):
+        return str(self.as_dict())
+
+    def from_dict(self, data):
+        if "id" in data:
+            self.id = int(data["id"])
+        else:
+            self.id = Cwe.NOTSET
+
+    def __eq__(self, other):
+        return self.id == other.id
+
+    def __ne__(self, other):
+        return self.id != other.id
+
+    def __hash__(self):
+        return id(self)
+
+
+class Issue:
+    def __init__(
+        self,
+        severity,
+        cwe=0,
+        confidence=constants.CONFIDENCE_DEFAULT,
+        text="",
+        ident=None,
+        lineno=None,
+        test_id="",
+        col_offset=-1,
+        end_col_offset=0,
+    ):
+        self.severity = severity
+        self.cwe = Cwe(cwe)
+        self.confidence = confidence
+        if isinstance(text, bytes):
+            text = text.decode("utf-8")
+        self.text = text
+        self.ident = ident
+        self.fname = ""
+        self.fdata = None
+        self.test = ""
+        self.test_id = test_id
+        self.lineno = lineno
+        self.col_offset = col_offset
+        self.end_col_offset = end_col_offset
+        self.linerange = []
+
+    def __str__(self):
+        return (
+            "Issue: '%s' from %s:%s: CWE: %s, Severity: %s Confidence: "
+            "%s at %s:%i:%i"
+        ) % (
+            self.text,
+            self.test_id,
+            (self.ident or self.test),
+            str(self.cwe),
+            self.severity,
+            self.confidence,
+            self.fname,
+            self.lineno,
+            self.col_offset,
+        )
+
+    def __eq__(self, other):
+        # if the issue text, severity, confidence, and filename match, it's
+        # the same issue from our perspective
+        match_types = [
+            "text",
+            "severity",
+            "cwe",
+            "confidence",
+            "fname",
+            "test",
+            "test_id",
+        ]
+        return all(
+            getattr(self, field) == getattr(other, field)
+            for field in match_types
+        )
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return id(self)
+
+    def filter(self, severity, confidence):
+        """Utility to filter on confidence and severity
+
+        This function determines whether an issue should be included by
+        comparing the severity and confidence rating of the issue to minimum
+        thresholds specified in 'severity' and 'confidence' respectively.
+
+        Formatters should call manager.filter_results() directly.
+
+        This will return false if either the confidence or severity of the
+        issue are lower than the given threshold values.
+
+        :param severity: Severity threshold
+        :param confidence: Confidence threshold
+        :return: True/False depending on whether issue meets threshold
+
+        """
+        rank = constants.RANKING
+        return rank.index(self.severity) >= rank.index(
+            severity
+        ) and rank.index(self.confidence) >= rank.index(confidence)
+
+    def get_code(self, max_lines=3, tabbed=False):
+        """Gets lines of code from a file the generated this issue.
+
+        :param max_lines: Max lines of context to return
+        :param tabbed: Use tabbing in the output
+        :return: strings of code
+        """
+        lines = []
+        max_lines = max(max_lines, 1)
+        lmin = max(1, self.lineno - max_lines // 2)
+        lmax = lmin + len(self.linerange) + max_lines - 1
+
+        if self.fname == "<stdin>":
+            self.fdata.seek(0)
+            for line_num in range(1, lmin):
+                self.fdata.readline()
+
+        tmplt = "%i\t%s" if tabbed else "%i %s"
+        for line in range(lmin, lmax):
+            if self.fname == "<stdin>":
+                text = self.fdata.readline()
+            else:
+                text = linecache.getline(self.fname, line)
+
+            if isinstance(text, bytes):
+                text = text.decode("utf-8")
+
+            if not len(text):
+                break
+            lines.append(tmplt % (line, text))
+        return "".join(lines)
+
+    def as_dict(self, with_code=True, max_lines=3):
+        """Convert the issue to a dict of values for outputting."""
+        out = {
+            "filename": self.fname,
+            "test_name": self.test,
+            "test_id": self.test_id,
+            "issue_severity": self.severity,
+            "issue_cwe": self.cwe.as_dict(),
+            "issue_confidence": self.confidence,
+            "issue_text": self.text.encode("utf-8").decode("utf-8"),
+            "line_number": self.lineno,
+            "line_range": self.linerange,
+            "col_offset": self.col_offset,
+            "end_col_offset": self.end_col_offset,
+        }
+
+        if with_code:
+            out["code"] = self.get_code(max_lines=max_lines)
+        return out
+
+    def from_dict(self, data, with_code=True):
+        self.code = data["code"]
+        self.fname = data["filename"]
+        self.severity = data["issue_severity"]
+        self.cwe = cwe_from_dict(data["issue_cwe"])
+        self.confidence = data["issue_confidence"]
+        self.text = data["issue_text"]
+        self.test = data["test_name"]
+        self.test_id = data["test_id"]
+        self.lineno = data["line_number"]
+        self.linerange = data["line_range"]
+        self.col_offset = data.get("col_offset", 0)
+        self.end_col_offset = data.get("end_col_offset", 0)
+
+
+def cwe_from_dict(data):
+    cwe = Cwe()
+    cwe.from_dict(data)
+    return cwe
+
+
+def issue_from_dict(data):
+    i = Issue(severity=data["issue_severity"])
+    i.from_dict(data)
+    return i

tasks/candidate-0260-security-appsec/tests/fixtures/legacy_latin1.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+# -*- coding: latin-1 -*-
+# cf. https://trojansource.codes & https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-42574
+# Some special characters: ������
+access_level = "user"
+if access_level != 'none??': # Check if admin ??' and access_level != 'user
+    print("You are an admin.\n")

tasks/candidate-0260-security-appsec/tests/fixtures/pristine_env_manifest.json

@@ -0,0 +1,94 @@
+{
+  "artifacts": [
+    "output.json"
+  ],
+  "detect_deletion": true,
+  "files": {
+    "CONTRACT.md": "7456ee10fb2e7c33e119ac3f04eeabe1a15cf0e1a455bac46656bfa6ea5f3913",
+    "Dockerfile": "fdc4026cc5e1301ffb6bdfd12f61c9d1591909ddf05501b43ef6ade47d01641f",
+    "run_scan.py": "b44a492a1332d71cccadc4b1a9a2c58f658883428ad577fa6f318e114d6c5d91",
+    "vendor/pycqa-bandit/LICENSE": "09e8a9bcec8067104652c168685ab0931e7868f9c8284b66f5ae6edae5f1130b",
+    "vendor/pycqa-bandit/bandit-1.7.5.dist-info/METADATA": "59108770d4658c0360b2e9c86e27f055e9e5ef35c697d6b6d269bcc022ccbb38",
+    "vendor/pycqa-bandit/bandit/__init__.py": "ca3a2ef11c721e9c7acc78d87016b8fc251f7cd60874444608fc7a3e2ac0a3ef",
+    "vendor/pycqa-bandit/bandit/__main__.py": "3ed9ca3c4e64f55efd02b3ec704a3313daeec1420cb87958bf7ca208c279501b",
+    "vendor/pycqa-bandit/bandit/blacklists/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/pycqa-bandit/bandit/blacklists/calls.py": "40254e78109932bc4b328e042d46ee842b76428ad37147bdbf3a850d1d13d665",
+    "vendor/pycqa-bandit/bandit/blacklists/imports.py": "de508d0f4d83a0313d1051cf7858447a0ccfdd84d96f8764f5109403ef7a4de9",
+    "vendor/pycqa-bandit/bandit/blacklists/utils.py": "3819bc766990b20a79fdd25c9b6f9e022ebdbb9797ba378e60383ace130d7933",
+    "vendor/pycqa-bandit/bandit/cli/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/pycqa-bandit/bandit/cli/baseline.py": "40dee0d068a3b6439a7a09c52878e581d76655dd1fae4b8eedada03b00bcb77b",
+    "vendor/pycqa-bandit/bandit/cli/config_generator.py": "1bdc0dd770f4aa59abefaa11ad4ae5777f8846a5f046466b405347df2cfdc0d7",
+    "vendor/pycqa-bandit/bandit/cli/main.py": "519ac1c8d66457369d322126acaafc0d7b1f8ee2ef2e80f5855acd9bba7eb8ca",
+    "vendor/pycqa-bandit/bandit/core/__init__.py": "370c4dab05265082414309ec386e7c9ef8baa30125762c869a49228346bee27c",
+    "vendor/pycqa-bandit/bandit/core/blacklisting.py": "ee4cdba88761a49af9061b858bd4b7ec83e780f457affbe592d5135274aeef26",
+    "vendor/pycqa-bandit/bandit/core/config.py": "e950a458ddcf146206f71e0516b36306f8537dfc5167f2849e2a4d9a58336aff",
+    "vendor/pycqa-bandit/bandit/core/constants.py": "c9a07692cef678eceb9df37bc4eaf7cc55b1b1cf1e08c9e9a672018fefc99a7d",
+    "vendor/pycqa-bandit/bandit/core/context.py": "dcdd0367efcd944c8e5256deed90d4765f07a5be0af6a3a249ca8e4b84f597b5",
+    "vendor/pycqa-bandit/bandit/core/docs_utils.py": "8835b0c785d39c8700c9084ba7a0d2c8ff42d4cda99200362ad6faf3a7327ff2",
+    "vendor/pycqa-bandit/bandit/core/extension_loader.py": "eb0f2a13ae00f2f614eb03f7af25597e7ed8c72e52169c3fcc49c1e6db567b25",
+    "vendor/pycqa-bandit/bandit/core/issue.py": "d2829a8c785f7ad9029be05125a9c655f59e7a90eed89cddb56612a954832beb",
+    "vendor/pycqa-bandit/bandit/core/manager.py": "561781823859ec089e3345a78760b667b24bbd7034de4e7cb4eb4b8f81718940",
+    "vendor/pycqa-bandit/bandit/core/meta_ast.py": "ac051d2f0b26e1e4cf374a17bf3c8839f557b2e295f7730b309b140bcea14d67",
+    "vendor/pycqa-bandit/bandit/core/metrics.py": "c038cf9abba346ccdaa98d332355bbb554d56219c2fa41e8f3009a7f9bd82810",
+    "vendor/pycqa-bandit/bandit/core/node_visitor.py": "698bd7153c0d26e16cc273279fc9a1c87af9d19a74900b7ba0b1d0de2340b0ae",
+    "vendor/pycqa-bandit/bandit/core/test_properties.py": "fe57ad4e4ef2f52a794b245aab67252de3518ca0969cec6e720946b5430b1394",
+    "vendor/pycqa-bandit/bandit/core/test_set.py": "8f0799ede2b520686875a6c5e831cefc384130cac7c45534dd1e7fcf8b12ac97",
+    "vendor/pycqa-bandit/bandit/core/tester.py": "c8ccc6c44fe3d57a466026e3823deda8de3df3fba12be0a9fc9d8d1f29d82040",
+    "vendor/pycqa-bandit/bandit/core/utils.py": "39717618552eb8ddde759e4998c840f7e25e0f13805241e29215e5808ef7f6c3",
+    "vendor/pycqa-bandit/bandit/formatters/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/pycqa-bandit/bandit/formatters/csv.py": "2224cb9dc571de19e7ec0ee926927963dbf189b8711c8bd99c685ece16182928",
+    "vendor/pycqa-bandit/bandit/formatters/custom.py": "db51a0acb89a4ad927a150fd194fac5a4bb89caee1248e0eefea60c8741a71bc",
+    "vendor/pycqa-bandit/bandit/formatters/html.py": "54d1e698a02c65657f4be44e7780c45c977f532d62a4ebdb0f9d01ce286e6ca5",
+    "vendor/pycqa-bandit/bandit/formatters/json.py": "c8ce446444513dfee3259bb52b8e62f2475090c96cf0d20730623e3e40451c84",
+    "vendor/pycqa-bandit/bandit/formatters/sarif.py": "294017268f86b7e98e5fa0a68c5dc543e848828fcf4290a4c0c52b360b40583a",
+    "vendor/pycqa-bandit/bandit/formatters/screen.py": "c9670c85642f5fb5a02509a4c8dcc509af81664657db49567e58662f7a9a5324",
+    "vendor/pycqa-bandit/bandit/formatters/text.py": "d4d8a8587053d5290a98bd7472c96c5bc493840971af93c6abe5e33fa0e76f4c",
+    "vendor/pycqa-bandit/bandit/formatters/utils.py": "31799c5c2d5f05e45b51140aa94b6a84f32d00430ee88ebe308c1c76b23f5050",
+    "vendor/pycqa-bandit/bandit/formatters/xml.py": "a5bb1aebab589467f26eaebf37980e85380a9d2427bc916cdfdcfccc50b069ce",
+    "vendor/pycqa-bandit/bandit/formatters/yaml.py": "4a2407e643059203c19511d7c535aa3507b846a7d93eef771db14e024b1d9b41",
+    "vendor/pycqa-bandit/bandit/plugins/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/pycqa-bandit/bandit/plugins/app_debug.py": "d19a7e0d388b9eebc5fa39592a10842bef58cd131c51cec94ba9b1595d358457",
+    "vendor/pycqa-bandit/bandit/plugins/asserts.py": "88e3f95918dda4573c8fada922443f731f8b6035b5692bfcaa97dd53bf00a175",
+    "vendor/pycqa-bandit/bandit/plugins/crypto_request_no_cert_validation.py": "03211280167b26dce279e2539d15eed249277fba20d41e4623eeae03790b6e5b",
+    "vendor/pycqa-bandit/bandit/plugins/django_sql_injection.py": "90406328d917a61cc109aed58b2a23227b65d9aed2e6c95db8f549550736048a",
+    "vendor/pycqa-bandit/bandit/plugins/django_xss.py": "25062b318ca7424aee01a26b275ba6cc149a70d1fb06a210dcaa61b2f21b71e1",
+    "vendor/pycqa-bandit/bandit/plugins/exec.py": "e64a2c4a6808f18d9733867fe61c08abb5914e67697c333913bb97613686c60a",
+    "vendor/pycqa-bandit/bandit/plugins/general_bad_file_permissions.py": "f13e7d08ff9a96e06d5e441dcb24099631622ef2b8c95232ddf0d2820c39dc48",
+    "vendor/pycqa-bandit/bandit/plugins/general_bind_all_interfaces.py": "327f180647c5e50c21c7541130707ee47367ce14789de3f4948ffa2f242be068",
+    "vendor/pycqa-bandit/bandit/plugins/general_hardcoded_password.py": "4bd5c7099544f77f9e3066597b11b7efc0edab8137d97d87c9f60e169c62c8d5",
+    "vendor/pycqa-bandit/bandit/plugins/general_hardcoded_tmp.py": "3e0be399b5896f6aca4ad2cf2cc16015ed9194415c144285659c3e44aea5a117",
+    "vendor/pycqa-bandit/bandit/plugins/hashlib_insecure_functions.py": "3817e3dc7e6152075ed7c68bbed4725df56ff3181c8efceb72032cb6d7fd4f90",
+    "vendor/pycqa-bandit/bandit/plugins/injection_paramiko.py": "6c06ea1fee021d06358214298e5724f8f97c0caab81ba8c9a004026373d2cd8c",
+    "vendor/pycqa-bandit/bandit/plugins/injection_shell.py": "ba13206eb243ffc3fda1a34539cd2a22d00277c6ed24094340c21e87d179a7a8",
+    "vendor/pycqa-bandit/bandit/plugins/injection_sql.py": "0d5ac613bcf31e62d71fce8c0c02d29dd7d77ea2d58cc72d0d6cc10aaaa51fb4",
+    "vendor/pycqa-bandit/bandit/plugins/injection_wildcard.py": "19e1c9721a03c542ee68b782c4cc98b89af15530b5bf1f24e894ac5e6e410c53",
+    "vendor/pycqa-bandit/bandit/plugins/insecure_ssl_tls.py": "56b47dab23b263ba35513070f85c34e866c4f3b48ee300ff8f5dbb7ab55f0cb4",
+    "vendor/pycqa-bandit/bandit/plugins/jinja2_templates.py": "17f8945a12d145bf0d6fc3c0d793086d56d1db7a3da65a6e0175d9aa07e2d8d3",
+    "vendor/pycqa-bandit/bandit/plugins/logging_config_insecure_listen.py": "5330ed2d3888c119eaa4f8cf2196ddb586f7d814f91398768610b6fa6f64c465",
+    "vendor/pycqa-bandit/bandit/plugins/mako_templates.py": "5642ff97e522ac36aba39b7f0872640aaef5fcdab1782f875ae3710a811798c4",
+    "vendor/pycqa-bandit/bandit/plugins/markupsafe_markup_xss.py": "4131705def7d30adba32d1049a7ead94d772f688d063404c64dbca319ddc0168",
+    "vendor/pycqa-bandit/bandit/plugins/pytorch_load.py": "79d18fa40c6f29629de12cf9edf1f828888bdb01716db430f157fe50cc7281e4",
+    "vendor/pycqa-bandit/bandit/plugins/request_without_timeout.py": "20969d3c2c1054401767787762c720be00c8cddac7334fe3a3362244ddf49321",
+    "vendor/pycqa-bandit/bandit/plugins/snmp_security_check.py": "b537689d174a30ab3946ae28e0e5b39d6e3fae39dad948674ad34b653286e7c2",
+    "vendor/pycqa-bandit/bandit/plugins/ssh_no_host_key_verification.py": "d45ab1e64e60b4bbe75a4e06cfb6d05f0ab1e133b12335066bea2e60140636c2",
+    "vendor/pycqa-bandit/bandit/plugins/tarfile_unsafe_members.py": "e46266dfd9d080739cb2f0773e9012ea786b35cfad855e4c3380a8173ad17740",
+    "vendor/pycqa-bandit/bandit/plugins/trojansource.py": "1b4119b410ac64e019656e1c6eeec581a665a8a723b80b51c51e78e5c0b1dffa",
+    "vendor/pycqa-bandit/bandit/plugins/try_except_continue.py": "2be56b412fd89e27c5c33e460b52c05331874db6e1f66f8b1ee0da2708004b9a",
+    "vendor/pycqa-bandit/bandit/plugins/try_except_pass.py": "0f03e28b389c7285ad804f3a684994f6668a5b55bc26e271a8e967ba67b59e2b",
+    "vendor/pycqa-bandit/bandit/plugins/weak_cryptographic_key.py": "4861f760cdcb881adc9ae3b41a39d0b990959b8d9dd82ebc9757462ad9f035bf",
+    "vendor/pycqa-bandit/bandit/plugins/yaml_load.py": "6ce7c264139c49707700020d25bbaf70790779ba3eab2332038d79e4b827c768",
+    "vendor/pycqa-bandit/examples/trojansource.py": "1abb885312fe41a3892feae543d41d069cad943905fc35e90e37d81a9a411009",
+    "vendor/pycqa-bandit/examples/trojansource_latin1.py": "6e1661b10a02dbc00ed543a4f3768a9ed40264da571c9f481c9041ea060378f8",
+    "vendor/pycqa-bandit/requirements.txt": "366a288bfdb81a63160657739eb7d1f4de36fbae02306331256f4f4eeda803b8",
+    "vendor/pycqa-bandit/setup.cfg": "df3bc2edb4a49f8e591dc67867cef094cff9b7ad8b30be87c432be9e046a5d2d",
+    "vendor/pycqa-bandit/tests/functional/test_functional.py": "8869e57f343ce5fe5c1bcd4d549c67e801177151645ab07b065f7768b148227f",
+    "workload/fixtures/clean_issue.py": "d2829a8c785f7ad9029be05125a9c655f59e7a90eed89cddb56612a954832beb",
+    "workload/fixtures/legacy_latin1.py": "6e1661b10a02dbc00ed543a4f3768a9ed40264da571c9f481c9041ea060378f8",
+    "workload/fixtures/trojansource.py": "1abb885312fe41a3892feae543d41d069cad943905fc35e90e37d81a9a411009"
+  },
+  "mutable": [
+    "vendor/pycqa-bandit/bandit/core/tester.py",
+    "vendor/pycqa-bandit/bandit/plugins/trojansource.py"
+  ],
+  "schema_version": "tbench.pristine_env_manifest.v1"
+}

tasks/candidate-0260-security-appsec/tests/fixtures/trojansource.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+# cf. https://trojansource.codes/ & https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-42574
+access_level = "user"
+if access_level != 'none‮⁦': # Check if admin ⁩⁦' and access_level != 'user
+    print("You are an admin.\n")

tasks/candidate-0260-security-appsec/tests/task_test.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -u
+mkdir -p /logs/verifier
+# tbench-anti-hack-guard:v1
+export PYTHONNOUSERSITE=1
+export PYTHONDONTWRITEBYTECODE=1
+# Fail open when the verifier image has no python3 (node-only tests images are
+# excluded from the RL set but still verifiable natively): a missing
+# interpreter must not swallow the grader's own reward write.
+if command -v python3 >/dev/null 2>&1 && [ -f /tests/anti_hack_guard.py ]; then
+  if ! python3 /tests/anti_hack_guard.py; then
+    # Guard already wrote reward=0; the reward file is the grading contract.
+    exit 0
+  fi
+fi
+
+
+python3 -m pytest --ctrf /logs/verifier/ctrf.json -q /tests/test_outputs.py
+status=$?
+if [ "$status" -eq 0 ]; then printf '1\n' > /logs/verifier/reward.txt; else printf '0\n' > /logs/verifier/reward.txt; fi
+exit "$status"

tasks/candidate-0260-security-appsec/tests/test.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Terminal-Bench grading: the task's own test script (task_test.sh here) writes /logs/verifier/reward.txt.
+# "-1" there is its crash sentinel: a testbed failure, so no reward is written (not scored).
+CWD=/app
+mkdir -p /logs/verifier
+# the task's anti-hack guard rejects files planted in the workspace: drop what agent harnesses leave there
+for d in .opencode .claude .codex .gemini .goose .aider.tags.cache.v4; do
+  grep -qx "$d" /var/lib/mimo/before 2>/dev/null || rm -rf "$CWD/$d"
+done
+cd "$CWD" && bash /tests/task_test.sh
+R=$(cat /logs/verifier/reward.txt 2>/dev/null | tr -d '[:space:]')
+if [ -z "$R" ] || [ "$R" = "-1" ]; then
+  rm -f /logs/verifier/reward.txt
+  echo "the tests crashed before grading (reward '${R}'): not scored" >&2
+  exit 1
+fi

tasks/candidate-0260-security-appsec/tests/test_outputs.py

@@ -0,0 +1,126 @@
+import hashlib
+import json
+import sys
+from pathlib import Path
+import tokenize
+
+import pytest
+
+sys.path.insert(0, "/app/vendor/pycqa-bandit")
+from bandit.core.issue import Issue
+from bandit.core.tester import BanditTester
+from bandit.plugins.trojansource import BIDI_CHARACTERS, trojansource
+
+FIXTURES = Path("/tests/fixtures")
+OUTPUT = Path("/app/output.json")
+EXPECTED_NAMES = ["clean_issue.py", "legacy_latin1.py", "trojansource.py"]
+
+
+class Metrics:
+    def note_nosec(self):
+        pass
+
+    def note_skipped_test(self):
+        pass
+
+
+class TestSet:
+    def __init__(self, tests):
+        self.tests = tests
+
+    def get_tests(self, checktype):
+        return self.tests if checktype == "File" else []
+
+
+def run_file(path, tests=None, context_range=None):
+    data = path.read_bytes()
+    tester = BanditTester(TestSet(tests or [trojansource]), False, {}, Metrics())
+    tester.run_tests({
+        "file_data": data,
+        "filename": str(path),
+        "lineno": 0,
+        "linerange": context_range or [0, 1],
+        "col_offset": 0,
+    }, "File")
+    return tester.results
+
+
+def independent_location(path):
+    data = path.read_bytes()
+    with path.open("rb") as source:
+        encoding, _ = tokenize.detect_encoding(source.readline)
+    text = data.decode(encoding)
+    for lineno, line in enumerate(text.splitlines(), 1):
+        for character in BIDI_CHARACTERS:
+            if character in line:
+                return lineno, line.index(character) + 1
+    return None
+
+
+def load_output():
+    assert OUTPUT.is_file(), "producer did not create /app/output.json"
+    payload = json.loads(OUTPUT.read_text())
+    assert payload["output_schema_version"] == "bandit_trojan_repair.v1"
+    assert list(payload) == ["cases", "output_schema_version", "summary"]
+    return payload
+
+
+def case_map(payload):
+    return {case["name"]: case for case in payload["cases"]}
+
+
+def test_gate_schema_and_fixture_coverage():
+    payload = load_output()
+    cases = case_map(payload)
+    assert [case["name"] for case in payload["cases"]] == EXPECTED_NAMES
+    assert set(cases) == set(EXPECTED_NAMES)
+    assert payload["summary"]["total_findings"] == 1
+    assert payload["summary"]["clean_files"] == 2
+
+
+def test_core_independent_security_location():
+    payload = case_map(load_output())
+    expected = independent_location(FIXTURES / "trojansource.py")
+    assert expected == (4, 25)
+    issues = payload["trojansource.py"]["issues"]
+    assert len(issues) == 1
+    issue = issues[0]
+    assert issue["test_id"] == "B613"
+    assert issue["severity"] == "HIGH"
+    assert issue["confidence"] == "MEDIUM"
+    assert (issue["lineno"], issue["col_offset"]) == expected
+    assert issue["linerange"] == [4]
+
+
+def test_core_context_enrichment_and_bytes():
+    payload = case_map(load_output())
+    issue = payload["trojansource.py"]["issues"][0]
+    assert issue["fname"] == "/app/workload/fixtures/trojansource.py"
+    assert issue["cwe_id"] == 838
+    assert issue["has_fdata"] is True
+    assert run_file(FIXTURES / "trojansource.py")[0].linerange == [4]
+
+
+def test_edge_encoding_clean_and_generic_fallback():
+    payload = case_map(load_output())
+    assert payload["legacy_latin1.py"]["issues"] == []
+    assert payload["clean_issue.py"]["issues"] == []
+
+    def generic(context):
+        return Issue(severity="LOW", confidence="LOW", text="generic")
+
+    generic._test_id = "X001"
+    generic_results = run_file(FIXTURES / "clean_issue.py", [generic], [7, 8])
+    assert len(generic_results) == 1
+    assert generic_results[0].linerange == [7, 8]
+    assert generic_results[0].lineno == 0
+
+
+def test_gate_protects_nonmutable_source_assets():
+    expected = {
+        "bandit/core/issue.py": "d2829a8c785f7ad9029be05125a9c655f59e7a90eed89cddb56612a954832beb",
+        "bandit/core/context.py": "dcdd0367efcd944c8e5256deed90d4765f07a5be0af6a3a249ca8e4b84f597b5",
+    }
+    for relative, digest in expected.items():
+        actual = hashlib.sha256((Path("/app/vendor/pycqa-bandit") / relative).read_bytes()).hexdigest()
+        assert actual == digest, relative

tasks/candidate-0308-security-forensics/environment/Dockerfile

@@ -0,0 +1,3 @@
+# The task's image, pinned by digest (the same as [environment].docker_image).
+# Setup runs at start from [environment.healthcheck]; environment/setup/ is its readable copy.
+FROM docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:c1b2d7e5807fef4065b79fe92e1dfef047503159349ced9b19941b48f684c4e6

tasks/candidate-0308-security-forensics/environment/setup/setup.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Runs once, as root, before the agent starts: Harbor's [environment.healthcheck] unpacks this folder into
+# /var/lib/mimo and runs it. Generated by mimo_harbor; see its README for how each step maps to Xiaomi's harness.
+M=/var/lib/mimo
+[ -f "$M/ready" ] && exit 0
+chmod 700 "$M"
+fail() { echo "setup: $*" >&2; exit 1; }
+# the answer-leak blocklist (mimoagent), applied to /etc/hosts by the agent right after it installs
+write_blocklist() { cp "$M/files/blocklist" "$M/blocklist"; }
+
+# Terminal-Bench rows (in the General domain): the Harbor convention itself. Scrub test leftovers from the image and
+# remember what was in the workspace, so harness residue can be told apart from the agent's work at grading time.
+rm -rf /tests
+find /logs/verifier -mindepth 1 -delete 2>/dev/null || true
+ls -A /app 2>/dev/null > "$M/before" || true
+
+touch "$M/ready"
+echo "setup done"

tasks/candidate-0308-security-forensics/instruction.md

@@ -0,0 +1,33 @@
+You are an agent, your current working directory is /app.
+
+You can use the tools available to you to interact with the computer to assist the user in completing tasks.
+
+# Repair the Windows forensic plugin integration
+
+The vendored Volatility3 tree contains a partially completed API migration in
+the Windows forensic plugins. The shared `Handles` plugin now exposes its
+handle-table helpers as context-explicit classmethods and has a newer plugin
+version. Several consumers still use the old contract.
+
+Work in `/app/vendor/volatility3`. Repair the integration in all four existing
+consumer modules: `callbacks.py`, `dumpfiles.py`, `poolscanner.py`, and
+`psxview.py`. Preserve the upstream filtering and invalid-memory behavior.
+
+Requirements:
+
+1. Every consumer must declare the current `Handles` requirement version.
+2. Calls to `get_type_map`, `find_cookie`, and `handles` must use the
+   context-explicit classmethod interface, passing the active kernel module
+   name and handle table where applicable.
+3. Do not replace the forensic traversal with constants, a new evaluator, or
+   a separate script. Keep the existing plugin dependency graph intact.
+4. Run a compile smoke check that does not leave generated bytecode in the
+   source tree, then write `/app/output.json` with exactly
+   this schema:
+
+```json
+{"schema_version":"volatility-repair-report.v1","modules":["callbacks","dumpfiles","poolscanner","psxview"],"checks":{"requirements":4,"context_calls":true,"compile":true}}
+```
+
+The report is a summary of the repaired source tree, not a substitute for the
+source repair. Runtime is offline and no packages or files may be downloaded.

tasks/candidate-0308-security-forensics/task.toml

@@ -0,0 +1,39 @@
+schema_version = "1.4"
+
+[task]
+name = "mimo-v2.6-rl/candidate-0308-security-forensics"
+description = "MiMo-V2.6-RL terminal task candidate-0308-security-forensics"
+keywords = ["mimo-v2.6-rl", "terminal"]
+
+[metadata]
+adapter = "mimo_harbor 1.0.0"
+domain = "terminal"
+original_allow_internet = false
+reference_harness = "XiaomiMiMo/verl a2ad9f6 + XiaomiMiMo/mimoagent 467f0a1"
+reference_step_limit = 500
+source_dataset = "XiaomiMiMo/MiMo-V2.6-RL-oss"
+source_id = "candidate-0308-security-forensics"
+source_revision = "639865fd3374018d6cb29b9fb82dd531406fcf5f"
+
+[agent]
+timeout_sec = 900.0
+
+[verifier]
+timeout_sec = 240.0
+user = "root"
+
+[environment]
+docker_image = "docker.io/xiaomimimo/mimo-v2.6-rl-oss@sha256:c1b2d7e5807fef4065b79fe92e1dfef047503159349ced9b19941b48f684c4e6"
+workdir = "/app"
+cpus = 1
+memory_mb = 2048
+storage_mb = 10240
+network_mode = "public"
+build_timeout_sec = 1800.0
+
+[environment.healthcheck]
+# one-time setup before the agent (environment/setup/setup.sh)
+command = "bash -c 'test -f /var/lib/mimo/ready || { mkdir -p /var/lib/mimo && echo H4sIAAAAAAAC/+2T30/UQBDH77l/xddCEAx3PVAhgUiCkegLL+iDCSFk206vm9vuNrvbq0T83532gJP4qr44n5e2+2PmO9+ZBopdOwv15C8yZ47n8/E5//158Pbo8PH9Yf34zeujCeaTf0AXovKccvJ/svUiy7XNchXqZAtXnQ1wtqB9qADvXNxHTpXzhFgT1IJsxGBYDCf4pHzu/MuAa7Ir7Z1teHdWkzKxLmoqljfobKuKZeDLOqBypiQPbaPjVNlK+czoPGt046BsCT8k13GGj2TJq0gl8jsM27f1mOoUgYhPBFxdnH+4vOCIHrXrQaqoWRa1aFTL2Ry+auUazdr4pqUQZsnlu2cZk2tMK6Tbl5knVd6luMHODuibjpgnRd24Ejyyw4E0qZQ2u3v4DipqhzQMv8wJtl+lONs5PF1fOjjFD65qdMmGnvzUkFoiN65YGh0idoeso4F7bG7bGs31sdKMYpHVLnBVXO3GZa8XdYSq4mBZZNfYdmNC0nsd6fYp7qiraMdKKm0oZE9b6bi4+RwUssQv5BttlZm+J8u2edcH7Go7pl47b1C6Rmm7dzIurvuMwtkVC9PODi0gU83wufBdjkhcnqEquhV5brN3zXhPN1zJ0FlO6qmhJudS+lpF9DxcDxl755eBh4QnLrjHbvHxoMuOUCjL88c2mZI947HbRB9d4gYPAcAxF16V2i4QdUOzxDeY+grZoC0klebxyoxbhIwl6kqzkCmbUFIbaxxgWpKhSDg8y0paZbYzBvf3iL6jxARMz5Fxx55tn63NHf+N9OlwEl3Hnm7GKvllZNhVS2kyEQRBEARBEARBEARBEARBEARBEARBEARBEIQ/xk8LxjaZACgAAA== | base64 -d | tar -xzf - -C /var/lib/mimo && bash /var/lib/mimo/setup.sh; }'"
+timeout_sec = 1200.0
+retries = 0
+interval_sec = 5.0

tasks/candidate-0308-security-forensics/tests/anti_hack_guard.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""TBench in-pod anti-hack guard.
+
+Runs at the very start of ``tests/test.sh``, inside the verifier container,
+after the agent's ``/app`` has been copied in.  The RL harness materialises
+``tests/`` into the MAIN container only after the agent exits, so the agent
+cannot see or tamper with this file — which makes it the right place to reject
+workspace pollution the agent planted during the episode.
+
+Detection (any hit -> write reward=0 and exit non-zero):
+
+1. **Planted interpreter hooks.**  ``conftest.py`` / ``sitecustomize.py`` /
+   ``usercustomize.py`` / ``*.pth`` / ``pytest.ini`` / ``.coveragerc`` /
+   ``tox.ini`` anywhere under ``/app`` whose path is NOT listed in the pristine
+   manifest.  Upstream vendor trees that legitimately ship a ``conftest.py``
+   are listed in the manifest and are therefore not false positives.
+2. **Protected-file mutation.**  Any manifest entry whose sha256 changed while
+   its path is outside the declared mutable set.
+3. **Protected-file deletion.**  Any non-mutable, non-artifact manifest entry
+   that vanished.
+
+The manifest is generated from the pristine ``environment/`` tree and shipped
+as ``tests/fixtures/pristine_env_manifest.json``.  A missing manifest degrades to
+name-only detection so the guard never blocks an uninstrumented task.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+
+SCHEMA = "tbench.pristine_env_manifest.v1"
+
+APP = Path(os.environ.get("TBENCH_APP_ROOT", "/app"))
+FIXTURES = Path(os.environ.get("TBENCH_FIXTURES", "/tests/fixtures"))
+MANIFEST = FIXTURES / "pristine_env_manifest.json"
+REWARD = Path(os.environ.get("TBENCH_REWARD_FILE", "/logs/verifier/reward.txt"))
+
+DANGEROUS_NAMES = {
+    "conftest.py",
+    "sitecustomize.py",
+    "usercustomize.py",
+    "pytest.ini",
+    ".coveragerc",
+    "tox.ini",
+    "pyproject.toml",  # only dangerous when planted; upstream copies are in the manifest
+}
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def is_dangerous(rel: str) -> bool:
+    name = rel.rsplit("/", 1)[-1]
+    return name in DANGEROUS_NAMES or name.endswith(".pth")
+
+
+def load_manifest() -> dict | None:
+    if not MANIFEST.is_file():
+        return None
+    try:
+        doc = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(doc, dict) or not isinstance(doc.get("files"), dict):
+        return None
+    return doc
+
+
+def reject(reason: str, reward: Path | None = None) -> int:
+    target = REWARD if reward is None else reward
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text("0\n", encoding="utf-8")
+    except OSError as exc:  # pragma: no cover - reward file is the contract
+        print(f"anti_hack_guard: cannot write reward file: {exc}", file=sys.stderr)
+        return 2
+    print(f"anti_hack_guard: REJECT {reason}", file=sys.stderr)
+    return 1
+
+
+def scan(manifest: dict | None, app: Path | None = None) -> str | None:
+    app_root = APP if app is None else app
+    files: dict[str, str] = (manifest or {}).get("files") or {}
+    mutable_set = {
+        entry.lstrip("/")
+        for entry in (manifest or {}).get("mutable") or []
+        if isinstance(entry, str)
+    }
+    artifacts = {
+        str(entry).removeprefix("/app/").lstrip("/")
+        for entry in (manifest or {}).get("artifacts") or []
+        if isinstance(entry, str)
+    }
+
+    if not app_root.is_dir():
+        return None
+
+    for path in sorted(app_root.rglob("*")):
+        if not path.is_file() or path.is_symlink():
+            continue
+        rel = path.relative_to(app_root).as_posix()
+        if is_dangerous(rel) and rel not in files:
+            return f"planted_interpreter_hook:{rel}"
+
+    if manifest is None:
+        return None
+
+    # Deletion detection is only sound when the built image is known to equal
+    # the source tree (plain ``COPY . /app``).  A multi-stage or dockerignored
+    # build legitimately omits files, and rejecting those would zero out the
+    # oracle for a perfectly good task.
+    detect_deletion = bool(manifest.get("detect_deletion", True))
+    for rel, expected in files.items():
+        if rel in mutable_set or rel in artifacts:
+            continue
+        path = app_root / rel
+        if not path.exists():
+            if detect_deletion:
+                return f"protected_file_deleted:{rel}"
+            continue
+        if not path.is_file():
+            continue
+        if sha256(path) != expected:
+            return f"protected_file_mutated:{rel}"
+    return None
+
+
+def main(app: Path | None = None, reward: Path | None = None) -> int:
+    manifest = load_manifest()
+    reason = scan(manifest, app=app)
+    if reason:
+        return reject(reason, reward=reward)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tasks/candidate-0308-security-forensics/tests/fixtures/pristine_env_manifest.json

@@ -0,0 +1,447 @@
+{
+  "artifacts": [
+    "output.json"
+  ],
+  "detect_deletion": true,
+  "files": {
+    "Dockerfile": "fdc4026cc5e1301ffb6bdfd12f61c9d1591909ddf05501b43ef6ade47d01641f",
+    "vendor/volatility3/LICENSE.txt": "6e905a859f6d5ebf23d4b7cdfb8ac425c4ec5dd02b3b274901a967f3e452eb37",
+    "vendor/volatility3/README.md": "73c05763987e3f1b5981ed3d47b420fed47a2232244b3d5ef8fba121730dfcb5",
+    "vendor/volatility3/pyproject.toml": "46d29ab8b8a039dc5e271c5f43690adeea2db98cf151900fef527d55b10fae71",
+    "vendor/volatility3/test/README.md": "ca2771f3200e0022e6bfc2d644191f145c49ce7f73695c1ca8cb6327c8c1c57d",
+    "vendor/volatility3/test/__init__.py": "8220379102c0318f90757dd7699f5d9f5983e58b9dc334d38faf9ad7b3f1e345",
+    "vendor/volatility3/test/conftest.py": "f5e11b689c4a68973496fa965175fd75a82574cf1de8027f44eded00ab8d5336",
+    "vendor/volatility3/test/known_files.json": "d7cc8470355856d27ee156c52bea91fa7fb05a1aa86be79c3d5044471846b405",
+    "vendor/volatility3/test/plugins/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/volatility3/test/plugins/linux/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/volatility3/test/plugins/linux/linux.py": "e6ed8861b09464b764208b4f7851eac629b61f75a2f500f85d974c464b921edb",
+    "vendor/volatility3/test/plugins/windows/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.driverirp.DriverIrp.json": "4350c99b637e27a05b8658719bc0d5f304b9fc5015981149a1293e9080613b3a",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.info.Info.json": "b52f346be8e5f0754b3472cda0a530ca705b2e14c48cb3fa57effe70faa9a813",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.pstree.PsTree.json": "9eca61b982e817b487c18c807da46a75f1d6d45f7b0b891414884821edbb3a76",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.registry.hivescan.HiveScan.json": "9520ae74954138240efcc28274f00aa6b9aa7dc308137a8153aec26b65fc9c4a",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.registry.printkey.PrintKey.json": "43698c976c1fa3d380e0c95c86e030e89b87e3beae8be2742d15ead1fb23784b",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.registry.userassist.UserAssist.json": "52af150344596d5762adfe2b7bd2f293cf22d6cdb666eb7b1625062132e2d2d7",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.sessions.Sessions.json": "8ff42d192cf5fd96ee4f31b3634d5bdc140acb5e0145ee8233f0909263ee630f",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.shimcachemem.ShimcacheMem.json": "7f8db0ab2414c51f5b715dc90cb90a6f9ba8a2db879f6c27485c08453c978679",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.timers.Timers.json": "f66c9b4a288cccdc5d1b46e7b61c835e4d9c7df571153ba4e3175751614cbe54",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.unloadedmodules.UnloadedModules.json": "308fa385fea56f7318c4dddd5ce1594444b18e009d451e6510ab78831561be65",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.vadinfo.VadInfo.json": "3c176bed2371b15e41e0ecbe1cb6f0093059cd152f4d3f4b4ee25ddba515774d",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.vadwalk.VadWalk.json": "83129b17962f24084d086977b917871d5082426f74f08b041ec529ff270e96f3",
+    "vendor/volatility3/test/plugins/windows/test_data/windows.virtmap.VirtMap.json": "588fbae61d1f2873d073d83869d56d5c2fd618fff1fa721ea3992c091f0af121",
+    "vendor/volatility3/test/plugins/windows/test_scheduled_tasks.py": "396e2ba87a44afd9441d2b50d34384fa3069ef3447cb887604e50799c6046370",
+    "vendor/volatility3/test/plugins/windows/windows.py": "484afaccb954bd6a98d3d7525b3ecc75a84b381dbb1556bbde5f7d453c653fb5",
+    "vendor/volatility3/test/test_volatility.py": "9fc7864ba4d0cc135a42e25fa2a9c12ae72d591664ac176b3ee4d4009e4e1983",
+    "vendor/volatility3/test/volatility3_code_analysis.py": "787e85ec3823b8d1a64b248eacd72178665ecb4facaedc707181737ed6a930d9",
+    "vendor/volatility3/volatility3/__init__.py": "776eb233ecb8d0c88af337ccc9288ab64ffae8160958c945038f09ad4a6ec93f",
+    "vendor/volatility3/volatility3/cli/__init__.py": "e8393758c707522e0c8f6f2086ecdd40ad8fb2bd600a22ef22e3024464946869",
+    "vendor/volatility3/volatility3/cli/text_filter.py": "72b5e31bf2eb29925315d9e0c9574ecb10a1503ce3df1ba0d10873df540a12ca",
+    "vendor/volatility3/volatility3/cli/text_renderer.py": "c333661b4bad071dda0925bb93c33237d6738dc4a99bfd9752c50c5948d4461b",
+    "vendor/volatility3/volatility3/cli/volargparse.py": "199fc73141d46625142a8f4d257f13c5b9c692fcc949cee439f6c9f25fc502e7",
+    "vendor/volatility3/volatility3/cli/volshell/__init__.py": "9ab94dfe89a2979893fbcb31915c756d45b68ba6f8f395199ae67c1b1693e95e",
+    "vendor/volatility3/volatility3/cli/volshell/generic.py": "99f36d20eba3c8a838a026475c2dee15949efa5396645f59786b8091f7a846c3",
+    "vendor/volatility3/volatility3/cli/volshell/linux.py": "343126e4db1347be9fe5c9b703b7bd1889a93910ed70e1a0efcb8826032e3ccd",
+    "vendor/volatility3/volatility3/cli/volshell/mac.py": "d79a7cc49eac2b9d3294a7108a9017b40c8945144ecd82985fce4e57351cf59b",
+    "vendor/volatility3/volatility3/cli/volshell/windows.py": "adfb08b286e11fead1e0478ea12394eb652a805837e911370e786278c0fb29d7",
+    "vendor/volatility3/volatility3/framework/__init__.py": "5f86d67fa4b9720777ce574601315b5c164bbef58e56c75fe664c2daf34c3a2e",
+    "vendor/volatility3/volatility3/framework/automagic/__init__.py": "b8f7119283003c503e4814311257996bef3268575369f822d655e6da54026b81",
+    "vendor/volatility3/volatility3/framework/automagic/construct_layers.py": "186fc01b3d592701f09711da214b99df86724cb5bff2e5022d632506c54450d6",
+    "vendor/volatility3/volatility3/framework/automagic/linux.py": "10a96021641332979151fb7e4d27731368a0cfba76556b9c2d4aed749b594165",
+    "vendor/volatility3/volatility3/framework/automagic/mac.py": "477fd031151b6774ffd4624549c726b8fc1ac73aec61c580056d6d360b738060",
+    "vendor/volatility3/volatility3/framework/automagic/module.py": "f0f23b0818dd58cd6b248a90f3d25bb663fef70383589479a71d11e5a0baba1b",
+    "vendor/volatility3/volatility3/framework/automagic/pdbscan.py": "5d8931aa6e2086cbc49d6c91f542730c32217b33be1504666abc2a213432ff5d",
+    "vendor/volatility3/volatility3/framework/automagic/stacker.py": "f4095931da4f351fcd86a2a09b7a3a12af96710bd61b1be3c84ba29c8c89278c",
+    "vendor/volatility3/volatility3/framework/automagic/symbol_cache.py": "43d2d999955e14500d11cb1251efc1446aef1a8ec860f691c9bb42cc4e7d9647",
+    "vendor/volatility3/volatility3/framework/automagic/symbol_finder.py": "4b620cee645f4b2f2accef34785590aa89d234d91ef4dd63460b7d678a7f78d7",
+    "vendor/volatility3/volatility3/framework/automagic/windows.py": "78a0db0fd8fb80cd787b6e253984825c4121feac60e11498fba47e23cddfd43b",
+    "vendor/volatility3/volatility3/framework/configuration/__init__.py": "961443689e43ecd546f8a963a89916b301939bbc908ac6116a6dfa8e681c5ec5",
+    "vendor/volatility3/volatility3/framework/configuration/requirements.py": "f8ab484f857f20383009f4186732347fbb810d6553beaa12ea6254b8ceb9e3d5",
+    "vendor/volatility3/volatility3/framework/constants/__init__.py": "43ea1f2351ba0038e146bd780e5f5830acf1e13731a79e8588e54c85c25fb96f",
+    "vendor/volatility3/volatility3/framework/constants/_version.py": "2411cd18470eccf6ae0c980adbd73db876a677bb9bac75a34cbaaf5268ca1bc6",
+    "vendor/volatility3/volatility3/framework/constants/architectures.py": "d2bbe705b8cb41fd8c131bd67e2fe0f1bc1a1ac26d1e691291bd5b3f7ab0f7a4",
+    "vendor/volatility3/volatility3/framework/constants/linux/__init__.py": "0a9ec5fd5809cfcc8dda043d306031e6027174847a3ffdcb8171ef3ca0440e28",
+    "vendor/volatility3/volatility3/framework/constants/windows/__init__.py": "a982c8c71085f918cb5c0be12b4c5fe34cab551d96d2f08cb284929b5781e9d9",
+    "vendor/volatility3/volatility3/framework/contexts/__init__.py": "95fa59d4696138d383652cc1dc2084e9b708535bb238490fea6aeaf53cbf3031",
+    "vendor/volatility3/volatility3/framework/deprecation.py": "544c2b8f3184abf608bd587b7c540a06a771eaa97e1d61bfc193778ca20986ea",
+    "vendor/volatility3/volatility3/framework/exceptions.py": "1f0e36721e3ec1f45dddeb7d9a35534c583bb79bffd0441c571e9384e3211a76",
+    "vendor/volatility3/volatility3/framework/interfaces/__init__.py": "77c7ba2db4a3ea463406118398e0351481cdddec648def8e48df86bcdbeb4bd8",
+    "vendor/volatility3/volatility3/framework/interfaces/automagic.py": "cb62ba7389396340b09266c3d4b1badda8fd886f2e32e108dc28ff5c0149bf6f",
+    "vendor/volatility3/volatility3/framework/interfaces/configuration.py": "d392170e1ebabe8c44a840196bd4354bc9ea3527e5911920d560eb378c8f854c",
+    "vendor/volatility3/volatility3/framework/interfaces/context.py": "b0c87c02f1bd3aee2634215beebbb88c9e1885de6eb8895978468d97b3d8d295",
+    "vendor/volatility3/volatility3/framework/interfaces/layers.py": "98e8e1f5a6210456d4e68ec37dc6cea8896a2fbf6aaa9eb33dc7513215da06bc",
+    "vendor/volatility3/volatility3/framework/interfaces/objects.py": "f7190db08a1fd98909fa957744af694283bfcc5d68a003e46ce2dbde022bc0a0",
+    "vendor/volatility3/volatility3/framework/interfaces/plugins.py": "ad4ba64495fed12e8fd9dd54766107eaca55f7ffbe9d1900eb54ac641fe55af2",
+    "vendor/volatility3/volatility3/framework/interfaces/renderers.py": "377bfac72b92b7285659b8d7a1a4ddf20e153686f92d6082be8862ff2d3b9052",
+    "vendor/volatility3/volatility3/framework/interfaces/symbols.py": "bdaea33a9ee820598fe5e89ce12f9e03957d0806089dee6cbaea7128f300a088",
+    "vendor/volatility3/volatility3/framework/layers/__init__.py": "44046ac1fe6673112cd7fb7ff09ab9165b2fd790af54b140b90d86fb70539f7c",
+    "vendor/volatility3/volatility3/framework/layers/avml.py": "49740a2373ed000621a517ab667dad07b07d7401b4322db4ffacdec2d1a5247a",
+    "vendor/volatility3/volatility3/framework/layers/cloudstorage.py": "50a030149384bb0be22d2ca6d2899bae75dadfa9acd8e8717c949355ff026df3",
+    "vendor/volatility3/volatility3/framework/layers/codecs/__init__.py": "6cbea80c589264cf3db68611dbec238b0c3cdc15c69a089976881daa990966cd",
+    "vendor/volatility3/volatility3/framework/layers/crash.py": "9639b6fad700f9a3e3824cb4408b9bd8431642867e55eb0dc91cd34c45677893",
+    "vendor/volatility3/volatility3/framework/layers/elf.py": "bf44818e1f69501a8f183d456c61580a871bf7ee5990b0e2b1b78900e569704f",
+    "vendor/volatility3/volatility3/framework/layers/intel.py": "6a1cc280d254afb426f6f854702f5dff6840fa85e91271cd9bd1ae64d67d8560",
+    "vendor/volatility3/volatility3/framework/layers/leechcore.py": "b0006a679f0c0fe0d4ff21918efb39d38c7bb2955d0aecfda8d7ec368744b5a5",
+    "vendor/volatility3/volatility3/framework/layers/lime.py": "ef3483de0db9708812af16e8fb4b4e49f6c73626b926799e4735eb8a8426d5b8",
+    "vendor/volatility3/volatility3/framework/layers/linear.py": "775e20b830f1600f1af27b2fc7a2ac811e37e864ca60d237e57966ca99cd2116",
+    "vendor/volatility3/volatility3/framework/layers/msf.py": "63d6d20e0b4cd78a4974660a53ce1160ce86903f571a7351c59c47bcc29e81d7",
+    "vendor/volatility3/volatility3/framework/layers/physical.py": "49065728f89b0187ebfe02af8f10283e9702e5b88e5910ab35b516e2169d9828",
+    "vendor/volatility3/volatility3/framework/layers/qemu.py": "d3ec0c2a4e8f14d555506520526bc01531cc050e0ff0604863fe99756b92b94b",
+    "vendor/volatility3/volatility3/framework/layers/registry.py": "faa15b5006b9359e85773358503de745f6f164019c318eb973ace88d41be6784",
+    "vendor/volatility3/volatility3/framework/layers/resources.py": "0cc84eb4c835fbd98f03ac6463ba0ef54a7056a076ed075c95ee089a8d323b0a",
+    "vendor/volatility3/volatility3/framework/layers/scanners/__init__.py": "c9ef412950973004146850acb415786a120d444bd0075ebb2e6ec3eb13d195ed",
+    "vendor/volatility3/volatility3/framework/layers/scanners/multiregexp.py": "c44694e3ae6f30e144e7eaf0b2375d8c922894bfa8f776944a70ba7a53d565fc",
+    "vendor/volatility3/volatility3/framework/layers/segmented.py": "05f1d832e3539407917fec87ce23ba14216998321dc87e124ec218e6e5e98979",
+    "vendor/volatility3/volatility3/framework/layers/vmware.py": "6840c4e28ee50ea2e9f47ec6aece67452731529cd1aa1b19ba35ece0626cbf40",
+    "vendor/volatility3/volatility3/framework/layers/xen.py": "d6c6d58f38e24cce9eca34d39c34501a59e1c9e565d56a58feb5ec966c58b85c",
+    "vendor/volatility3/volatility3/framework/objects/__init__.py": "40899bd37ff68896d5b31cd0f816fb874cccd557e09f65252fe5e56f2ce91521",
+    "vendor/volatility3/volatility3/framework/objects/templates.py": "23d7476152f50403c28ce97e929e979571192d435620ab4786e7323cdab9d117",
+    "vendor/volatility3/volatility3/framework/objects/utility.py": "cb60dc26b46bee53878b410ed2b6fe8cf535e8aa4e4b74c2c5fedafdcc951ec1",
+    "vendor/volatility3/volatility3/framework/plugins/__init__.py": "85f6b193fc002bf7fc4bdbd0730571424344462babe2ab2b3a61caaf0399860a",
+    "vendor/volatility3/volatility3/framework/plugins/banners.py": "28ebe131502ac52e3c21699e61baefbee59d53afc2bb1cf5dac3d36f814d207a",
+    "vendor/volatility3/volatility3/framework/plugins/configwriter.py": "3d5ffb2b8fd1f151c504d5f3e364159a4a68e9da6fb62f75a5d65800ce0e35ac",
+    "vendor/volatility3/volatility3/framework/plugins/frameworkinfo.py": "38f75866aa620dd745f6ed8b68fd736e9543549cc90f48f69e7541460ff48833",
+    "vendor/volatility3/volatility3/framework/plugins/isfinfo.py": "be4a058961e2779937dca0777348ccc07f9891cf2bd84603c0dd8cbc53928ab3",
+    "vendor/volatility3/volatility3/framework/plugins/layerwriter.py": "fb6789935df69339a4f450798019b82fd04d2b2b55f6fd5dd13152392b158416",
+    "vendor/volatility3/volatility3/framework/plugins/linux/__init__.py": "69cc5d45f71f0113e3be366a89aef2a6a62677acb6d669e9f387d39525d4a704",
+    "vendor/volatility3/volatility3/framework/plugins/linux/bash.py": "162cac7fe833a6e7a494bc9237812d416f2c904ab9e2a18cc495e6c3b0d52d55",
+    "vendor/volatility3/volatility3/framework/plugins/linux/boottime.py": "28e59cea60b43facd9e617b7a5986d069ad5f578fb1931a12c35ccd6b98f527c",
+    "vendor/volatility3/volatility3/framework/plugins/linux/capabilities.py": "3ee3ea8206bf7145021856aa916338232c3ea2590bdab3d02d3cf19b5965f48d",
+    "vendor/volatility3/volatility3/framework/plugins/linux/check_afinfo.py": "de2e6b2c6acac3a622822ee36ab89a16f7aafadac21419f025effac77c680eaf",
+    "vendor/volatility3/volatility3/framework/plugins/linux/check_creds.py": "2974d0d3f6f7428f2fc4f6629081bcd751cf7fe1858f4cfd57ce141bcd3a4bfa",
+    "vendor/volatility3/volatility3/framework/plugins/linux/check_idt.py": "24d65c33e466b6d17f87d84ffd3a974bd206e44f66977fa09504c035a4b76322",
+    "vendor/volatility3/volatility3/framework/plugins/linux/check_modules.py": "c88d8ffde4a8751580457dee4eb84de018444dfdc92827a0d890f4ac5d5a52a4",
+    "vendor/volatility3/volatility3/framework/plugins/linux/check_syscall.py": "5d8ebf36df307b40db8accc5976bd5a4979bc8935e45f1a8277020a651db1c5c",
+    "vendor/volatility3/volatility3/framework/plugins/linux/ebpf.py": "9439a7f780f80c9e4d2f4f0e77fbd099cb6facf5c510c10806ed7b3e2324e223",
+    "vendor/volatility3/volatility3/framework/plugins/linux/elfs.py": "1686657c63fd123d1e8cf7b2eb43140ad913df1fd37d29bce3e13081c91b733c",
+    "vendor/volatility3/volatility3/framework/plugins/linux/envars.py": "b5c0775595d48b31b4a61830d0fee90503f5141b9de85a85c23b787679afe47b",
+    "vendor/volatility3/volatility3/framework/plugins/linux/graphics/fbdev.py": "bdff2704b96f43e03b820ee6359809e5f0537f9f15530f82f1dd3afb14dd3b8e",
+    "vendor/volatility3/volatility3/framework/plugins/linux/hidden_modules.py": "6fc0f9fd3c87f54deaf22ff9d9e95ab30aa6a19679eb7bef9528eb94fb195637",
+    "vendor/volatility3/volatility3/framework/plugins/linux/iomem.py": "35a256f21097099afa80455dec6f4647f63e0d6268e5b7057fb75062c91f481c",
+    "vendor/volatility3/volatility3/framework/plugins/linux/ip.py": "263febbef9ed3fd6a6899b0eec2b64c3a6689dfaaccc9997ff80cd1a00ecb1be",
+    "vendor/volatility3/volatility3/framework/plugins/linux/kallsyms.py": "eb0dfe9103298456f2656937f42385cc3bfed7ac7002fb73ce9dcc68242f7ef4",
+    "vendor/volatility3/volatility3/framework/plugins/linux/keyboard_notifiers.py": "1e5fad98ccc5fcf782e9b329fb97423e9e5454607c3e40fe0d65d49d36674fac",
+    "vendor/volatility3/volatility3/framework/plugins/linux/kmsg.py": "6455ba3d1106b09ae314d1fb625b4d5b216d28249136ad1614e783fd2f88db38",
+    "vendor/volatility3/volatility3/framework/plugins/linux/kthreads.py": "4e68d38e737a28d3e9c77e679e48066a45092479a34dfe0ea6599d8997919526",
+    "vendor/volatility3/volatility3/framework/plugins/linux/library_list.py": "da1027f74b9434e9b7b1791e26be3b8c76038f0c3920dd252012924f58aa6984",
+    "vendor/volatility3/volatility3/framework/plugins/linux/lsmod.py": "92e86b8323c66a86e594fb1fa73398cd3fc7b0d35ca78d4e21718383e93e0342",
+    "vendor/volatility3/volatility3/framework/plugins/linux/lsof.py": "b6b6174de3c4910e64d87f79fa1f8471241d24664549403b4301b4ef9f0e4613",
+    "vendor/volatility3/volatility3/framework/plugins/linux/malfind.py": "a4446918c0171045cf0ab9a39be2b2d8f138eca8ab4fd1e872cf08e9516c53ff",
+    "vendor/volatility3/volatility3/framework/plugins/linux/module_extract.py": "90cf80a9213dc80887bf52703e4ecff02787b3b2075b9a892baf6321e2fd3715",
+    "vendor/volatility3/volatility3/framework/plugins/linux/modxview.py": "7f89470e83ce8140d4190b15184a1097e47c16ed9a75af201d57ea84feb65e98",
+    "vendor/volatility3/volatility3/framework/plugins/linux/mountinfo.py": "117671948a6786993383d1ab0048e8b7c12fc7f7e9be07552ce3172483962a37",
+    "vendor/volatility3/volatility3/framework/plugins/linux/netfilter.py": "f42a65f4b19ea6892eb12c2b21960fe995402c4b8d5bde47c9082b168e3c2e87",
+    "vendor/volatility3/volatility3/framework/plugins/linux/pagecache.py": "f54abf972d701847da73bcffdc0f43e49b43a8252d51076b8000fd8ddcc17db2",
+    "vendor/volatility3/volatility3/framework/plugins/linux/pidhashtable.py": "a3e29e1c69b71aaaf96803373d486cc0ba1712ccd59b3d4b14b2c7103d2daa8e",
+    "vendor/volatility3/volatility3/framework/plugins/linux/proc.py": "162da8d84cc10c5adab52a10747390ae3b13d306ca1143c44f5c859bf562b6ed",
+    "vendor/volatility3/volatility3/framework/plugins/linux/psaux.py": "214e265b5af92e208b59faa24da6bfb31a099ebb6f33493b55f3ce4c0c19cdb1",
+    "vendor/volatility3/volatility3/framework/plugins/linux/pscallstack.py": "49e404e9164c0c763d63ff2f02b8bdb1d2a68904cbdd996f03c42fd4ae09ee90",
+    "vendor/volatility3/volatility3/framework/plugins/linux/pslist.py": "0b3f259e17226d9d97a52bda672da728f6e8c29db1ef51ab6bd5af9b51edf812",
+    "vendor/volatility3/volatility3/framework/plugins/linux/psscan.py": "70b5fe46b408093045f71f4898d9ec393461a482698b960cd51f32eb22b33197",
+    "vendor/volatility3/volatility3/framework/plugins/linux/pstree.py": "5d55d0470055e1caa36dfa4b0cfb29cff12e4c608b26843c3d3beea8ed02262e",
+    "vendor/volatility3/volatility3/framework/plugins/linux/ptrace.py": "5358f6ca21a8c7418382652928d5a66cdfe50d9225dfa5484062deed1ee013eb",
+    "vendor/volatility3/volatility3/framework/plugins/linux/sockstat.py": "df8884f762eb0421bafa07cc07f909967e6147377317ea798fcc717cb3c5464c",
+    "vendor/volatility3/volatility3/framework/plugins/linux/tracing/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/volatility3/volatility3/framework/plugins/linux/tracing/ftrace.py": "44cafc31a5d95e9c32cfa7fb9faa8f68a73671068ce436a6406dbe4e1389d88e",
+    "vendor/volatility3/volatility3/framework/plugins/linux/tracing/perf_events.py": "c762a7ecf570867a3ff66365616614e3d2ff8bb837a5b336ba618c0acccfe0cb",
+    "vendor/volatility3/volatility3/framework/plugins/linux/tracing/tracepoints.py": "f56f81a1e8442bf5165d73a2f8745c599515bc6a27da3337409b37edbe27d47f",
+    "vendor/volatility3/volatility3/framework/plugins/linux/tty_check.py": "efa2d18a29d2acf7d3b4392caca90164e9d571c2e8942c0abc8b957ddb9dee80",
+    "vendor/volatility3/volatility3/framework/plugins/linux/vmaregexscan.py": "8ee07d249bc457be3c05444316fd9bfd853eccbb7ee8cc649b1e6957f4f245f7",
+    "vendor/volatility3/volatility3/framework/plugins/linux/vmayarascan.py": "ef2004ee5cccd5b337b88a74f4be8e556031ee67c713bca630095b6c1c3446d1",
+    "vendor/volatility3/volatility3/framework/plugins/linux/vmcoreinfo.py": "2366d7833d322a90699b8b591a50f80db98e9fd8ba770bbdfa12f04af68a427b",
+    "vendor/volatility3/volatility3/framework/plugins/mac/__init__.py": "b00300e5f698d7f97ecb05fc3f15836bf2740fa1d6f8d1e31d8820c825fed667",
+    "vendor/volatility3/volatility3/framework/plugins/mac/bash.py": "084bdce23ad3d8dd04fbf5db45648d41aea127b137e7a899c46c0389b49b0a72",
+    "vendor/volatility3/volatility3/framework/plugins/mac/check_syscall.py": "a21e9a6d1ed58e0a2408936ca8e4aa146235bdea1810e5bb8e36fb69f93cc326",
+    "vendor/volatility3/volatility3/framework/plugins/mac/check_sysctl.py": "19aa68f1b41e9c64474d1f14684aed38140adaa23f85cb83c9448210055cb46a",
+    "vendor/volatility3/volatility3/framework/plugins/mac/check_trap_table.py": "a71691298329b5ceae27875405ab0e8039d3b74befae47cc448002066cab269e",
+    "vendor/volatility3/volatility3/framework/plugins/mac/dmesg.py": "39a1af5b4db5349ad8a08181539cdd6d29f963f4a9bfc396005ef4ce91d48b91",
+    "vendor/volatility3/volatility3/framework/plugins/mac/ifconfig.py": "458e63ffcf5ed213d47b41fbee3ca38a28c3a1a8bcca38d20440d9408efbcb09",
+    "vendor/volatility3/volatility3/framework/plugins/mac/kauth_listeners.py": "bc9f117499d2a07859d14f7af5685798ab285d3b4f6851e34b5b9a7512389d56",
+    "vendor/volatility3/volatility3/framework/plugins/mac/kauth_scopes.py": "cd7e380043a8cb9bee2bcc438398901409e87ef9b421abc8847c9c3044aec9b6",
+    "vendor/volatility3/volatility3/framework/plugins/mac/kevents.py": "7cefd9130dbbf44351558ae7b4ba3d8f2344385ca6188b27d1de043ab88d43af",
+    "vendor/volatility3/volatility3/framework/plugins/mac/list_files.py": "aa71579295371b6210cfb2dbbbe9be67f8fa66ee881c9533ab5e03e0ff571d10",
+    "vendor/volatility3/volatility3/framework/plugins/mac/lsmod.py": "9af1ce27a1040728c193c9668735be613470172ca9fb6e6b6e822a3626ab3bdf",
+    "vendor/volatility3/volatility3/framework/plugins/mac/lsof.py": "cf76e076e02ee49b40e4cc588d15c323044b5a4228b627ea2f0be0e7c0b27cfd",
+    "vendor/volatility3/volatility3/framework/plugins/mac/malfind.py": "05c7f53027ec072b1718b49be568001c68007fadc182b39fb99d7fc9e91c1f2f",
+    "vendor/volatility3/volatility3/framework/plugins/mac/mount.py": "5aaa34f33b83c9167b4d7267100340968e6f1efbbc3f6e8d86534ce4ebaa993b",
+    "vendor/volatility3/volatility3/framework/plugins/mac/netstat.py": "b08e2e9ea5300c2c71b8bace37f3499a978f3ad1ebce364d80a622849e95afa5",
+    "vendor/volatility3/volatility3/framework/plugins/mac/proc_maps.py": "959a135c59a2a996b46a72a082a9ce74416d13f0eb2940b7b24f6e74deaa6d2a",
+    "vendor/volatility3/volatility3/framework/plugins/mac/psaux.py": "1b0f5db5ee08936c635530050fe1f983b43a8af783fe7e0b18a9617c5b787683",
+    "vendor/volatility3/volatility3/framework/plugins/mac/pslist.py": "baaeecb2b86762ffc393f717caa3e31045ccd95dd45f70daaf1533b095f024e5",
+    "vendor/volatility3/volatility3/framework/plugins/mac/pstree.py": "a7879be3bd039b763d60d5b4c21f6659c6931ace14c8ffd73e654a2bc0df45d4",
+    "vendor/volatility3/volatility3/framework/plugins/mac/socket_filters.py": "d8e28b1db176ea384ec47ca8d2237a62a057a1f4f92ac4eddd62e3fb16e099b3",
+    "vendor/volatility3/volatility3/framework/plugins/mac/timers.py": "81034ce4833c2a96f8eff4ea1b156b899b962ecf4b85ce8d9cbbbbe80bbc9534",
+    "vendor/volatility3/volatility3/framework/plugins/mac/trustedbsd.py": "4c120088faa0b44c6c2a1c595a828a8839497284406065fb0d1af502bd062e98",
+    "vendor/volatility3/volatility3/framework/plugins/mac/vfsevents.py": "a5748a02710d175a785ddeba14ae3664819a13dc611f3c9839abcb40f2183aa4",
+    "vendor/volatility3/volatility3/framework/plugins/regexscan.py": "eb8b741af56951783ba4fc980e7f851983f679e4cce6c0053764412f63979089",
+    "vendor/volatility3/volatility3/framework/plugins/timeliner.py": "af44c57ffd84dc5d3e0dd75da5500c1f40c4481c0460c72115773defc59118bb",
+    "vendor/volatility3/volatility3/framework/plugins/vmscan.py": "d4ef9ace9b78cdc5d7ef4456d0be75f29ab121465358155b49037bce4a09cfd9",
+    "vendor/volatility3/volatility3/framework/plugins/windows/__init__.py": "a59b80304c668414cbfa32697ac6a592a58af2c7183a44ac2da3a595b2b07f0b",
+    "vendor/volatility3/volatility3/framework/plugins/windows/amcache.py": "9b8db99871a1a5bc95c809e8f5d69c33da58711f2fcf8c7f20c5ccfff266e397",
+    "vendor/volatility3/volatility3/framework/plugins/windows/bigpools.py": "61d41060ce643e72f2f38adaa98cdf4893d18e539b3a029b415cc144bf6e57f5",
+    "vendor/volatility3/volatility3/framework/plugins/windows/cachedump.py": "d051789d30ae01b34442b86b389e3838aba2369111f915b3d063b2019416ef5d",
+    "vendor/volatility3/volatility3/framework/plugins/windows/callbacks.py": "6ebf78cc3c444473d3d60bdca962730b47767b20c5c6861aac2b34da51bd843e",
+    "vendor/volatility3/volatility3/framework/plugins/windows/cmdline.py": "1cdc3a173bdf8e654c24a81d3e55e2eaf58d8c8377c3cf91a3fce418d1e53e86",
+    "vendor/volatility3/volatility3/framework/plugins/windows/cmdscan.py": "bef07d9a39cebcd01530832168a3c834f8272757bf724ef49af6ffa3bebd14d8",
+    "vendor/volatility3/volatility3/framework/plugins/windows/consoles.py": "8e185d7274213b3fe8c1a5a2ce0b7060935cf9d07f6d1e8d39ff6af6a62e9d4b",
+    "vendor/volatility3/volatility3/framework/plugins/windows/crashinfo.py": "caf9489c30d7fd75fb706303457a727760915de3db7c0e85805662c1905eacb7",
+    "vendor/volatility3/volatility3/framework/plugins/windows/debugregisters.py": "91d843d894baa6488311ef4a02c7e70bf037dfb24c57e2e7b577cfff91a36321",
+    "vendor/volatility3/volatility3/framework/plugins/windows/deskscan.py": "f2b27d83b9c7000c4ea5ff5689634ed377970f28ee5b896f907309c22c1cb908",
+    "vendor/volatility3/volatility3/framework/plugins/windows/desktops.py": "3eb1633a7b5db100d2aa52b8a992668546fe0ea381b69f95dc88f5eda3dd6c19",
+    "vendor/volatility3/volatility3/framework/plugins/windows/devicetree.py": "feecc3208a8498e59cb9711f3ee53d8b7f28c97cfac300bb6780dd64ab7d2f12",
+    "vendor/volatility3/volatility3/framework/plugins/windows/direct_system_calls.py": "5116f44615ffc2088cf693d1f4af3284bda0dedcba8576d411ad8b18c70cdf47",
+    "vendor/volatility3/volatility3/framework/plugins/windows/dlllist.py": "c12babd3ff7edb885b93582c1509667d561a3b5641aeee28eadcfc42d4992590",
+    "vendor/volatility3/volatility3/framework/plugins/windows/driverirp.py": "de9d4d773b8d0055f19858c259ea863b639788add7706b459022ad20824f59cb",
+    "vendor/volatility3/volatility3/framework/plugins/windows/drivermodule.py": "35627d702a0e79bc38d7157d83e1b6211b5d0c8855efc73d851f924eb74a2198",
+    "vendor/volatility3/volatility3/framework/plugins/windows/driverscan.py": "e7ac4083870765e9c83039bab8fcab5aecbe526ead58ab1f20b25065908b0175",
+    "vendor/volatility3/volatility3/framework/plugins/windows/dumpfiles.py": "0bd8c2bfa3c3a05b374ef1a4de69dbd53de401ea9e12624d2f36a01db846766b",
+    "vendor/volatility3/volatility3/framework/plugins/windows/envars.py": "08494aa2e2e9bcabea5826ec96013cb4680c9073257c59a66e7413eada230374",
+    "vendor/volatility3/volatility3/framework/plugins/windows/filescan.py": "03965c56b48abfbf798ddd3f505a7edc6ba4ba75915ea541e9e9dae4438e2341",
+    "vendor/volatility3/volatility3/framework/plugins/windows/getservicesids.py": "cd5a09035e0dd7ed4ea1e38b032625d79ae08581b7668b5e1dc9d7a7a450e2ad",
+    "vendor/volatility3/volatility3/framework/plugins/windows/getsids.py": "a18cc318357e37994d3229c8b1595048445552a1b5e2937608c02a00754e0d31",
+    "vendor/volatility3/volatility3/framework/plugins/windows/handles.py": "13e0335729d92279232c5f8fd583cba23464e9495b965951400bdc76bf06146d",
+    "vendor/volatility3/volatility3/framework/plugins/windows/hashdump.py": "e666d816022c1161b4e6c2c11a9565205dd78603c088a8f9d0b83a5a9b115dd5",
+    "vendor/volatility3/volatility3/framework/plugins/windows/hollowprocesses.py": "6adbd1a221a4e3bb3a170ecc1e76e7df2c9801a5478841a08b4ad9a0058d963d",
+    "vendor/volatility3/volatility3/framework/plugins/windows/iat.py": "6cfd955e53c1d62466efca4884bde4a05419041084033e7eb68a3846506703e4",
+    "vendor/volatility3/volatility3/framework/plugins/windows/indirect_system_calls.py": "5482a07f404d2332a0a957b82f3c619e4b6fb2250a5dd41c4ff010dfdeb5e11b",
+    "vendor/volatility3/volatility3/framework/plugins/windows/info.py": "f47b866e86251f9e437dfd7514af932a6d9de5663fab0404d5d2a41abe003964",
+    "vendor/volatility3/volatility3/framework/plugins/windows/joblinks.py": "d69c01300e65b73c590b82e251ef6e63275aa9cd9d991e58728c2884980bb4ee",
+    "vendor/volatility3/volatility3/framework/plugins/windows/kpcrs.py": "f7d1c4684477f58b05ac4f935d916914909fca3e77635701f2c78cc786ddb832",
+    "vendor/volatility3/volatility3/framework/plugins/windows/ldrmodules.py": "c641c1a8282a8ef1a749809a025d47939a6f12d67b868270d3c2b70a18cfdf61",
+    "vendor/volatility3/volatility3/framework/plugins/windows/lsadump.py": "d4f7d83ac30ead83cc5daed5ce0bc47b4c5420e70ba108c260b4f52c9020890a",
+    "vendor/volatility3/volatility3/framework/plugins/windows/malfind.py": "1d45795c1ff4e4526fdfc1eb830ffb850248728fd7f594f6c9645ad5631a3e01",
+    "vendor/volatility3/volatility3/framework/plugins/windows/mbrscan.py": "3bc2aeb0ed65076ef339a16c9b2f0babf444f74a48b6c321ab8403e82132d5e0",
+    "vendor/volatility3/volatility3/framework/plugins/windows/memmap.py": "e6d9ce27968db0665afe503192749cc3b1855ed79b15e3adffdd837bfe7b3daf",
+    "vendor/volatility3/volatility3/framework/plugins/windows/mftscan.py": "5f51f49ed1892adc4fc8c6193cf01298d2fad6b06e043139b680d274df01eab7",
+    "vendor/volatility3/volatility3/framework/plugins/windows/modscan.py": "1fb077a9433a29d7800c3d39fd8fe0ee91fc9c08edcf690b588d76331bcb6253",
+    "vendor/volatility3/volatility3/framework/plugins/windows/modules.py": "1b37df625a4c358632c4f10771f7eb1d63c2475436e1ad32f44ed81f70765976",
+    "vendor/volatility3/volatility3/framework/plugins/windows/mutantscan.py": "9ee8ca7493584f4d20dd0ba49e58bc5a4653bd1beb1e81a46357bfaf9c4a1210",
+    "vendor/volatility3/volatility3/framework/plugins/windows/netscan.py": "5da3c4fb9fed4634adb6d72a686f8b18e5edf974ada25cd3c0c3826a3fd34e45",
+    "vendor/volatility3/volatility3/framework/plugins/windows/netstat.py": "943d2cc331955df4826aaaa1e41a721f72085d745df44857b37bc0004e09597a",
+    "vendor/volatility3/volatility3/framework/plugins/windows/orphan_kernel_threads.py": "b1038d27f67462ff3492ee388ba16d59da405fb72b583faf897e0be004f547c8",
+    "vendor/volatility3/volatility3/framework/plugins/windows/pe_symbols.py": "3b42cbc7ba61e6112accd900ed1b43d91b60f1bbe87953ab5188e256d46a14c7",
+    "vendor/volatility3/volatility3/framework/plugins/windows/pedump.py": "43f9992b033152fba61964d26822200d53403922fb81b117b8f1ca5e22080420",
+    "vendor/volatility3/volatility3/framework/plugins/windows/poolscanner.py": "e9538e6636a8a0ee04706cdcacbd50ddd8d95ecdef146cd0dc9fabd3613531d0",
+    "vendor/volatility3/volatility3/framework/plugins/windows/privileges.py": "d85628423c1bef699d226e3d8f374fee244344e7a8d8294610207eb15fd061aa",
+    "vendor/volatility3/volatility3/framework/plugins/windows/processghosting.py": "0876686ddd00f435a3c399e4e2afe96fc38dc5f24f04bcf885a5a6627dd50e09",
+    "vendor/volatility3/volatility3/framework/plugins/windows/pslist.py": "bd78f00b080780746f03b62591e8d95e8471a26db189e4b3aa8b413675e8d07b",
+    "vendor/volatility3/volatility3/framework/plugins/windows/psscan.py": "932e7989e7688c138a6a90df471b62ffd3695c71e01a064d8ec00d66342d3314",
+    "vendor/volatility3/volatility3/framework/plugins/windows/pstree.py": "dabaf587ac43b4c5546063152091e32315111341c9d30ac09c557b9936433854",
+    "vendor/volatility3/volatility3/framework/plugins/windows/psxview.py": "e1f974403ed5f0bee4900d435b5d40fcf778765cb164ae21c10d817f6c7c2d17",
+    "vendor/volatility3/volatility3/framework/plugins/windows/registry/__init__.py": "e706bdcd5437dd6797c092f7ac577e06da3e3964f0b2074a02aa8a6a7475a465",
+    "vendor/volatility3/volatility3/framework/plugins/windows/registry/amcache.py": "dbc2613f0fe80bf0e953d5bb51a14446db13bd3deed8d3d35082a40e917eec89",
+    "vendor/volatility3/volatility3/framework/plugins/windows/registry/cachedump.py": "1e5e604db8987f417f2ddf58d739d0c027e5c41d6276be494da1c51ce5fa4d4d",
+    "vendor/volatility3/volatility3/framework/plugins/windows/registry/getcellroutine.py": "7ffba7f04b87377accdcf4ec61847138ee8569b40ccbc0faaaf4050f1143cc3e",
+    "vendor/volatility3/volatility3/framework/plugins/windows/registry/hashdump.py": "3b5d4c10afa1fd4a5d6352140f06834831389a5465e6916953a59f28fc692d74",
+    "vendor/volatility3/volatility3/framework/plugins/windows/registry/hivelist.py": "7ac59abb9ba5485c257b833f9f3b23725872484e7ede81465028372d5bb20ee8",
+    "vendor/volatility3/volatility3/framework/plugins/windows/registry/hivescan.py": "0bb0c82a2fbcdebdbc376f311d62bb8dec851e1ac67c5f23e8c293c9688e36eb",
+    "vendor/volatility3/volatility3/framework/plugins/windows/registry/lsadump.py": "5b253b01f8d1393d470cd5cc4f0bae97b8a444d0f7d6ffa73177992e71705261",
+    "vendor/volatility3/volatility3/framework/plugins/windows/registry/printkey.py": "ba227e5bc68b5c9d2cb7d6367387d3e392d855d1620ea0b844821d2b02868815",
+    "vendor/volatility3/volatility3/framework/plugins/windows/registry/scheduled_tasks.py": "519e7eadbccda36c873dcbd4448c6cec394080b021dd8643e5b78705c82fbbda",
+    "vendor/volatility3/volatility3/framework/plugins/windows/registry/userassist.json": "15c6e3850a0c7836bd80c92a9a444eb807318899b10e43cb82d8fff015276dac",
+    "vendor/volatility3/volatility3/framework/plugins/windows/registry/userassist.py": "13ca145688d366323bc064ff538db058221056d5a8caec3d21ad9acf2de9bf00",
+    "vendor/volatility3/volatility3/framework/plugins/windows/scheduled_tasks.py": "df7aa807900e4b207c31974f7958bdd9bb99b15b2fbfd6a6eb9b2167e3a7f933",
+    "vendor/volatility3/volatility3/framework/plugins/windows/sessions.py": "cf8fa2133c3f30e47dc485dbd1486873e8e06c4d42a8cb1d4f52130d4becfb73",
+    "vendor/volatility3/volatility3/framework/plugins/windows/shimcachemem.py": "093f508af0645a5dc922d302276c7f5e8500819c9b7883102dcdf77c7352c3a8",
+    "vendor/volatility3/volatility3/framework/plugins/windows/sids_and_privileges.json": "0d5f32732a042ef4c52e772243b161921bc40668dcf3ba5d7e000e1360705985",
+    "vendor/volatility3/volatility3/framework/plugins/windows/skeleton_key_check.py": "1f3bf33c0059f26d654bed1ae18bcfccef65f34b77cec535c3c6056c746e982a",
+    "vendor/volatility3/volatility3/framework/plugins/windows/ssdt.py": "326164e85ef393bff72584168c44f5acd5ddefac2dd5bc02cc62f02b0cfa8cdb",
+    "vendor/volatility3/volatility3/framework/plugins/windows/strings.py": "3e123a012c89399369c91a62cb92aad37a75a4bf262e0458357f95225f8b2324",
+    "vendor/volatility3/volatility3/framework/plugins/windows/suspended_threads.py": "5d6fcc5cdc85f10df4157dde900ea64386d763a67aca9a63ad0b850067333c41",
+    "vendor/volatility3/volatility3/framework/plugins/windows/suspicious_threads.py": "f3493c83e9616da0d10d367dfa1df878dbcc287d3470f4c2cfb56971abcd01d3",
+    "vendor/volatility3/volatility3/framework/plugins/windows/svcdiff.py": "198576df9ccbccc44bf596908bd3eaf5fc1509c589c1006b255c9b3dd9398c67",
+    "vendor/volatility3/volatility3/framework/plugins/windows/svclist.py": "c827fef706c523395ba50870a6bba949497e1f2c29caeef37168687bf999b647",
+    "vendor/volatility3/volatility3/framework/plugins/windows/svcscan.py": "7ec9bd44c2a925342a13d6c173229a5498aa969d56d509900ef773de9a4be692",
+    "vendor/volatility3/volatility3/framework/plugins/windows/symlinkscan.py": "4cda58a55310dfd8fc4e67a7ec5cdadb7fd2ece9848215fddd0623c3598d79f3",
+    "vendor/volatility3/volatility3/framework/plugins/windows/thrdscan.py": "fe63a26ac0a3c6e5bc26f716e3c65770edc1b9446a31b3acfcdc7c14c70175db",
+    "vendor/volatility3/volatility3/framework/plugins/windows/threads.py": "c3d4d53cf53de219b3abdaa9d06fa96817d27b90959ab1afed6ac75583f39604",
+    "vendor/volatility3/volatility3/framework/plugins/windows/timers.py": "4bf40bb02da25b12ea6fbc24b8b49af51a266ea6fbb09a55723ec5827ad32919",
+    "vendor/volatility3/volatility3/framework/plugins/windows/truecrypt.py": "44b85d8f84b0e1a77dd5039c6d72479aaa30ef830e514b2bacbc1c224df6d542",
+    "vendor/volatility3/volatility3/framework/plugins/windows/unhooked_system_calls.py": "c9d371179f591bd73c0940dd607470f656942e2487c015cf5547962090f875a7",
+    "vendor/volatility3/volatility3/framework/plugins/windows/unloadedmodules.py": "054dcadd90a639e8da84d491d33e32df83186cb19e05eca604a507691eab9658",
+    "vendor/volatility3/volatility3/framework/plugins/windows/vadinfo.py": "7777247622ea709ddbda2acd3166a66e5e37389678efac78499a0b4e6bd9a6f5",
+    "vendor/volatility3/volatility3/framework/plugins/windows/vadregexscan.py": "0201e2564bc43884562a2736161362f062c7e6177f97289fc67a6b8a4e9d17cb",
+    "vendor/volatility3/volatility3/framework/plugins/windows/vadwalk.py": "ac74f3bc6bb51d5990d326f24d7d73b2ed3b62648c1b89a8597460df493e44b6",
+    "vendor/volatility3/volatility3/framework/plugins/windows/vadyarascan.py": "c4b721b8cc5ab895e9e16d37ae0c3a3379538632269b34ef24060ae51a8a9288",
+    "vendor/volatility3/volatility3/framework/plugins/windows/verinfo.py": "5dfff31730b4106b5763e997d5377da6893dfd4b4450993d1e767337badb6910",
+    "vendor/volatility3/volatility3/framework/plugins/windows/virtmap.py": "692a80a016ee7f48eee36fc6a9632b2465dde2fac38e5b33a9a28f65becf4598",
+    "vendor/volatility3/volatility3/framework/plugins/windows/windows.py": "92042688b7c8bdac38bfcd9f89d592fb3ca7d2f1c39d7d6170eee1d327b226b1",
+    "vendor/volatility3/volatility3/framework/plugins/windows/windowstations.py": "7cd17fe8076f5660dde385b0c45ea7d738d99f69daa72eea6c3ce5f697b4a8f9",
+    "vendor/volatility3/volatility3/framework/plugins/yarascan.py": "dd7a6b1e92d4a35eec3b3033a1e4fc15116c74e742307e7aa83621393c3e1b9f",
+    "vendor/volatility3/volatility3/framework/renderers/__init__.py": "96d351a96cdfb800c8d75707ab9c0336a871c6eae9379ce5bb75a73a066f6a7f",
+    "vendor/volatility3/volatility3/framework/renderers/conversion.py": "0af8425c9da0629cc2545edb5e74bfc32fb7f05536dd37d11444eaaeeec38ea8",
+    "vendor/volatility3/volatility3/framework/renderers/format_hints.py": "082c6756557787fc0fa6d497d834aa18f8399ec255dbdb8bfd14cfc3cb480b7f",
+    "vendor/volatility3/volatility3/framework/symbols/__init__.py": "f2a3d131ff30130606378707a58c9fc87681dea05c193e7871282040ae7a060d",
+    "vendor/volatility3/volatility3/framework/symbols/generic/__init__.py": "7b2814cfb670f2de5dcab226b3067875462e1977a1bba4d2b680964e4f7b0abc",
+    "vendor/volatility3/volatility3/framework/symbols/generic/qemu.json": "f6ae161a49da8a841be9e52f1872799a1573ab11e4e9aebd6495e30153575cd3",
+    "vendor/volatility3/volatility3/framework/symbols/intermed.py": "ee54fa1276b0b748db093f9a46553ea3ed5ed83052eac60ed1cb5e0d9ded51a3",
+    "vendor/volatility3/volatility3/framework/symbols/linux/__init__.py": "44eb2c07c3b8cc6fe8f9a7a3777870229c125de023a013672c8f108a658a4d83",
+    "vendor/volatility3/volatility3/framework/symbols/linux/bash.py": "b4cd5e3490e6c6c2445339ad5cbc2cf4142384ef87d0d6aa95e5a2012e67100b",
+    "vendor/volatility3/volatility3/framework/symbols/linux/bash32.json": "d0b2c3fb3d78f5bcb7ed0037aad0e488dd9d78656bb01570ef2ec809088d0351",
+    "vendor/volatility3/volatility3/framework/symbols/linux/bash64.json": "0406dce7641ce14912fe74c17c9d4aa08d428addec1f45609dc3135235057d99",
+    "vendor/volatility3/volatility3/framework/symbols/linux/elf.json": "ff93e5d38a61ffc6b19dabbeca4a4ea99fb499d4f8cf8bc538b797a2da112d08",
+    "vendor/volatility3/volatility3/framework/symbols/linux/extensions/__init__.py": "c377b994e028fd7e10f24a731f5903112d09dcc92360c1132aae96dc8339382a",
+    "vendor/volatility3/volatility3/framework/symbols/linux/extensions/bash.py": "5e4a867a152c5a4592d1f4e31dc5ac2befc7093cfb38bff8415d7dbcf78377e0",
+    "vendor/volatility3/volatility3/framework/symbols/linux/extensions/elf.py": "19bb78588f28d93e06f19388307a7a7d6581cc2e29f6d309461bc9cae9b3e46e",
+    "vendor/volatility3/volatility3/framework/symbols/linux/extensions/network.py": "2c9fead8cb326fe6af4ea640b36c589c7ed89c805ed0e072d8b951d265b5dce7",
+    "vendor/volatility3/volatility3/framework/symbols/linux/kallsyms.py": "4e853fd788c78913a3f53b67b8e10f3f8108507296adaf613e4f47defeacbcf0",
+    "vendor/volatility3/volatility3/framework/symbols/linux/network.py": "7c063be3eb7c805d34de2c8ced9ebf14d04f168331cc105abad17476d77ca443",
+    "vendor/volatility3/volatility3/framework/symbols/linux/utilities/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "vendor/volatility3/volatility3/framework/symbols/linux/utilities/module_extract.py": "954456f7e752c7c6ddfa53d6a38a14bc65e9a4039b1cf8c2e5028855911bab1f",
+    "vendor/volatility3/volatility3/framework/symbols/linux/utilities/modules.py": "e74670f24e0ea9fa119c88411f47899bec9d7cd5b3441f17d214ed33351d0145",
+    "vendor/volatility3/volatility3/framework/symbols/linux/utilities/tainting.py": "d916459a35b85e74f8d7784280ddd4782621249bea15c9a7417bb54a0afc4301",
+    "vendor/volatility3/volatility3/framework/symbols/linux/xen.json": "eaffb4d3b9b1b9c941b5b14d645bd13e7d2d2ced2cf783b38dcfb375667324bb",
+    "vendor/volatility3/volatility3/framework/symbols/mac/__init__.py": "f3515f6cf5b80eee3b9f2598478d9ac06dd6bc1496d7a9a7a0690e505ea4219d",
+    "vendor/volatility3/volatility3/framework/symbols/mac/extensions/__init__.py": "76df2be95d5e965fcf0deec407d8731aebb8fd1e693afa29b766cce15a5ee1fc",
+    "vendor/volatility3/volatility3/framework/symbols/metadata.py": "c8b5b400b0586667aa77fda88c8e6675652691777205a79aa5ed4f9bf927f224",
+    "vendor/volatility3/volatility3/framework/symbols/native.py": "6206f253916ffcd716520bac83d02319f7e372950858a21a7927153076cb5843",
+    "vendor/volatility3/volatility3/framework/symbols/windows/__init__.py": "77b3441936d83fbf1dcfadac381fe070f7d12c6953f8de3a6ed9a1a132001c10",
+    "vendor/volatility3/volatility3/framework/symbols/windows/bigpools/bigpools-vista-x64.json": "97e104dc229d8e711758f297ce7c9ab2ccc13fe8e1ca9be1bb9f6bb1df2b9432",
+    "vendor/volatility3/volatility3/framework/symbols/windows/bigpools/bigpools-vista-x86.json": "15c0fb404b7de02a3b84b42d2723b6175528f764742bcc3f7ded75e376046f1c",
+    "vendor/volatility3/volatility3/framework/symbols/windows/bigpools/bigpools-win10-x64.json": "aaf842ff851946fd0f83f3e281f81cff77b33bfbbc06bf87a12a52ac24de4a09",
+    "vendor/volatility3/volatility3/framework/symbols/windows/bigpools/bigpools-win10-x86.json": "4218883e314d15f2b88aa785c7d40c6befead867b277eb7e8acf691d3f5abdd3",
+    "vendor/volatility3/volatility3/framework/symbols/windows/bigpools/bigpools-x64.json": "8e00646a876a61d32d2e0d00155b69671ecd262ec8d257fbb2ea356e2f68a837",
+    "vendor/volatility3/volatility3/framework/symbols/windows/bigpools/bigpools-x86.json": "c86db46893358aeaf5762c67b83de016de6534ea031fe76c9d2bf90b8732e3d9",
+    "vendor/volatility3/volatility3/framework/symbols/windows/callbacks-x64.json": "f246fe8d9b187546fe78f72336a923a710255d712226bcc2f578c45b95c6c618",
+    "vendor/volatility3/volatility3/framework/symbols/windows/callbacks-x86.json": "712a16677e973918f8101d83c4493fbe63e913e97b6e1960a3d3ed79b48e4a79",
+    "vendor/volatility3/volatility3/framework/symbols/windows/consoles/consoles-win10-17763-3232-x64.json": "f9e0ba2d38b616990dab4ba75e658e15c2c008ac683877fdf0df1fe7932bc291",
+    "vendor/volatility3/volatility3/framework/symbols/windows/consoles/consoles-win10-17763-x64.json": "e5b0b1a836e9b3c1e3951d5846e54cd7cac1e9f4d1f2ff050a17e907f9cbc1ce",
+    "vendor/volatility3/volatility3/framework/symbols/windows/consoles/consoles-win10-18362-x64.json": "8bd2dcf099d78b4c57a2b3c18128c87b9b9c7608bc6f64b08eb82eacc3df2c76",
+    "vendor/volatility3/volatility3/framework/symbols/windows/consoles/consoles-win10-19041-x64.json": "dc9546f557c3b544d0bcd71042cfc4d1127a44d309fe83660a58b914cabb61d2",
+    "vendor/volatility3/volatility3/framework/symbols/windows/consoles/consoles-win10-20348-1970-x64.json": "e5cf79e05d00f7dd7ac4ede0cc8ec8c62ef487dbb808a04932cfa3fcf619447a",
+    "vendor/volatility3/volatility3/framework/symbols/windows/consoles/consoles-win10-20348-2461-x64.json": "4750b0c6c7112e2dea66e53da9984208ad878ecdd6eed84c0dafa3dc8a205d21",
+    "vendor/volatility3/volatility3/framework/symbols/windows/consoles/consoles-win10-20348-x64.json": "563b8485300253cc3b226f4e423330a5b571526640c95432500a65447463c5a3",
+    "vendor/volatility3/volatility3/framework/symbols/windows/consoles/consoles-win10-22000-x64.json": "34508f45adfaff5ff028c28bfc08d61306653c1ad9b7033a6fb64c0b95194598",
+    "vendor/volatility3/volatility3/framework/symbols/windows/consoles/consoles-win10-22621-3527-x64.json": "5c91afc2964829d02bfe31c055fc7aa20db134bfed4269b75d7394459a2db651",
+    "vendor/volatility3/volatility3/framework/symbols/windows/consoles/consoles-win10-22621-x64.json": "9ebbf87ff302adf8733b0f2c2208e4d32ec5007456980a8aff1502228fe5c00b",
+    "vendor/volatility3/volatility3/framework/symbols/windows/consoles/consoles-win10-25398-x64.json": "6aa3015a0c529c391420ebd5638928d4c0866bc4d660ddb7508048968b9439a7",
+    "vendor/volatility3/volatility3/framework/symbols/windows/crash.json": "b2349cba97f4f1a1bf079407f13269a7ebfd42f226515330b617b88b8da8d368",
+    "vendor/volatility3/volatility3/framework/symbols/windows/crash64.json": "4ebf6c9942393f7c2676112ffdddbae18334a5ad00c7853b0ccbd56adf8a982b",
+    "vendor/volatility3/volatility3/framework/symbols/windows/crash_common.json": "b3c098b1083b387daaabc95fa7e39e53d4c19ba40be853a340f88bd73226b944",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/__init__.py": "f24ab9bb2ceb69f86b62d6051e282e0f966e14313936c62ce94957760a6db827",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/callbacks.py": "5ad15b47359d9f8318c2d42a1bdf6b9dfe0526fc79aeb88281ad8450dbc97c86",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/consoles.py": "1b8472ab01398b9fae6c2b25757a4647ecb6110c5816e4e8f234fdce700cefe6",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/crash.py": "856decda19df9530adb8c34edccc09a4d8d7b9cb574b23426f302d2892863bf2",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/gui.py": "79d6ef0709ecdab126c91ae6dd1901a8d2697dde4249faf433fd55eac90af2d5",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/kdbg.py": "dc496105b9beaba0213d89ad78c2f8b4e55ad978936f91eb2699fb0cd1efbb55",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/mbr.py": "2b8aa9abc918cf882f86b15fe7971f5bb1bf81d778921c34ad5fcf8f616d079f",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/mft.py": "6293d79478d9430c8ce84d254827ce64359f564954d9294f644dbe5394f0442f",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/network.py": "add531e9d0e0944e03e74b5e9b7f3be50cc7ecd3c1256ccd4d83661874d5772e",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/pe.py": "25888748ab139628d585edb98d8559182a12b5a5b7795b8d10644d4013c7597f",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/pool.py": "67957662893760586219e635fa8f5029ef5e731510b426bbc2b30eac131a1e30",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/registry.py": "0ea8faa0fbd77659c45409423c6678f4163cd5006f0f295c54e8798631e85911",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/services.py": "a6582adbcfa739038355c51dab58f018e302a7270319b4104fa9a85e2376e218",
+    "vendor/volatility3/volatility3/framework/symbols/windows/extensions/shimcache.py": "8f616931e6b9851b8d60f63d5113c61ae1c2bb2a22b5c9c7ebe22b0eb47de50a",
+    "vendor/volatility3/volatility3/framework/symbols/windows/gui/gui-win10-10586-x64.json": "87280455f20b23334a6b53521056ac3605a54e181882ba7759a7196518f35977",
+    "vendor/volatility3/volatility3/framework/symbols/windows/gui/gui-win10-15063-x64.json": "d7c5fb21c720f202ae155ec399f95c8c6fed164c04ec9ec1545d82dacf29081f",
+    "vendor/volatility3/volatility3/framework/symbols/windows/gui/gui-win10-16299-x64.json": "923b68e6e988557d17c63eff25a9ddb33a11fbd7f0221eb5d5eef90044e38ea4",
+    "vendor/volatility3/volatility3/framework/symbols/windows/gui/gui-win10-17134-x64.json": "2dbfb0f911a02e257fd345976065a82d2407090330269fd323e5b1cd813fcd14",
+    "vendor/volatility3/volatility3/framework/symbols/windows/gui/gui-win10-17735-x64.json": "74b5ec6112580c1a267c88b1341d6439129d226207813c1ec0ae2e3cb0679676",
+    "vendor/volatility3/volatility3/framework/symbols/windows/gui/gui-win10-17763-x64.json": "42f3fda32235b61b02b9f21f731dccbc14038be42e36584699e8d9bf1b70d902",
+    "vendor/volatility3/volatility3/framework/symbols/windows/gui/gui-win10-18362-x64.json": "693235e7a3ebed46186cea2b53411ca3f708a3198d386267c322d9931d02a386",
+    "vendor/volatility3/volatility3/framework/symbols/windows/gui/gui-win10-19041-x64.json": "db87d5f9b3ed6e00cfecb227658d451b22e690c65bf909b81f3c87ab85db7d58",
+    "vendor/volatility3/volatility3/framework/symbols/windows/gui/gui-win10-19577-x64.json": "068eeb1d0d33214be6b0eec5383aee1f4b3fb2e54b34a82b499ae0818db13fed",
+    "vendor/volatility3/volatility3/framework/symbols/windows/gui/gui-win7sp0-x64.json": "f5e9690ee9d1ab54a7b30710601bfb68630840818d345ba07aa893f4d3972735",
+    "vendor/volatility3/volatility3/framework/symbols/windows/gui/gui-win7sp1-x64.json": "c6ef7781901d59f9c3cfeca6cc95617959b7271fb22bb77d4cec705483caf64b",
+    "vendor/volatility3/volatility3/framework/symbols/windows/gui/gui-win8-x64.json": "eb22c82c9dfa40d7e573cc8b1d3944436bea60c01bc4f7e896e5496d0441bb24",
+    "vendor/volatility3/volatility3/framework/symbols/windows/kdbg.json": "9232ae2afb1dfc95825fff9c7dee6ca23d3ca793ceb4f7a41c1eae4b273902fd",
+    "vendor/volatility3/volatility3/framework/symbols/windows/kerb_ecrypt.json": "08accc7d92e785a5ef3d48b0035882903c2c9e54bae8f0e07e09ed22e01e7872",
+    "vendor/volatility3/volatility3/framework/symbols/windows/mbr.json": "03cb08a71d6d1453cdd060862309f2d08281634161874d80083a74c4a0a77459",
+    "vendor/volatility3/volatility3/framework/symbols/windows/mft.json": "12b8ede2f1c5c43ba2af1f7c550153bd3afd8bac90d36014c05155c51534da36",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-vista-sp12-x64.json": "e74f540a9df2f24917ca666e0a398a210ff12b1ba66ad016e52af646d012a9a9",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-vista-x64.json": "300d8d03db2c6e422ec2d49115c6ea4d1e3ef0dd21ecad97b18c2cb62a94f11b",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-vista-x86.json": "54c23c206d2cf8dd551a2f552715917df03431d5f6be8f131aa6fd7addceaf54",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-10240-x86.json": "fdc692553db42a805b251f021c039dea1f46b6340eaa347ddfd4316027e77441",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-10586-x86.json": "c7dab68ed2e66e9236d5523864786787187f599a408fc4d73eee67487a47522b",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-14393-x86.json": "bbb0835d7663085db699e5744128e76e8f2316db9ad922b0dbb7bdb114650a00",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-15063-x64.json": "23008f542015e4e3a2d7428114a2517e3cdadde0ffa56b22019d1eca32a6a4f9",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-15063-x86.json": "dcf5a61c9eb06e80c96605099e1a8cb6862c0a4181e7a2453b04bfe9e47ac78e",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-16299-x64.json": "ff38f9c9e5634246b6ba91c4beee37a00442171bb4a67a03a7db920f7ef94b37",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-17134-x64.json": "9b34bf236f99d9b1d214b828110f3cf681ec965c6d1870aab89ffe8724ca1308",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-17134-x86.json": "54d69b1fb2d03efc8c146680b1945745e139b2052fb6dc77301cc229d8c66ebc",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-17763-x64.json": "4fcf4dd602dac3351fde707951293db88f278c4cb3c0d576ed8da4c0dd90dd0e",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-18362-x64.json": "45377ef57466e0e2793c9e5ce0cabd84ebbe30b9b6142ed61652a942d79cba1a",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-18363-x64.json": "94e33494a78c759f5695b1604e67f6303760b12b0e3181e2374353618238d4d6",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-19041-x64.json": "bffcb47d0591d1f17592f997aa34a1717eac2bfe71fa6253ca334287733b2b79",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-19041-x86.json": "edf5b8777e0e224529c8bbae46db5929d4f754ff3fd3859870dc2e223ba00c30",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-20348-x64.json": "ba65993432fb1c88543acfffb8a5d5be843d4911a3b6e3f79f17a17b38e63946",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win10-x64.json": "6c239adf810b43b53e126a30a931498398b40075f76fe7a2fb12a7d9b2710c4b",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win7-x64.json": "72bf57f96f7e5299728b3a7f109d6b497e027acf461e1c14c1a49c49387b54e2",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win7-x86.json": "1603d998af20b84134f17cbc5d236f2ff021ada15e361fe9d1c1d2308bb031fc",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win8-x64.json": "0c5243afa4b98e766d74d637922cfd039500c5a4557f428d0bdaa86a0dd10061",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win8-x86.json": "87cdacb9f167566abca985fd201ea5622cd86a4147b4956f7f936ba01730ce98",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win81-19935-x64.json": "0afad4fe47b1b09cedf19602645b273a97b68b6c4ebf35257cac9260e758cf53",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win81-x64.json": "110ed8e4bb05c9d0280bf1a6d7a227ddb0656b86dc450cc80429e309571093b7",
+    "vendor/volatility3/volatility3/framework/symbols/windows/netscan/netscan-win81-x86.json": "7b516694476ff2132096054ff807b912fb682ed83b0c2b14bb3d7e314ee1a692",
+    "vendor/volatility3/volatility3/framework/symbols/windows/pdb.json": "6358e296ad62191a0382e136ca31f7032bf45a6a06cd27ebcbf90620e0adf451",
+    "vendor/volatility3/volatility3/framework/symbols/windows/pdbconv.py": "ec95adaf761525ea3d74ec5311a17e7059fc45f868df04a4ef7f9c1a8457ce32",
+    "vendor/volatility3/volatility3/framework/symbols/windows/pdbutil.py": "32ded64d5bef4d171d814207c628027545fba286560f6d7f5846bc0c4754a3cc",
+    "vendor/volatility3/volatility3/framework/symbols/windows/pe.json": "981c17bb586e4b9a4683fac591075e5e4294f5dd0824acc4e90da818a0f86af1",
+    "vendor/volatility3/volatility3/framework/symbols/windows/poolheader-x64-win7.json": "8a3c2ac05ed690f8b912913c7eee813f3e7f082511b7e44abc7e877e64345e1c",
+    "vendor/volatility3/volatility3/framework/symbols/windows/poolheader-x64.json": "f5ab8b21cf9c478b9d0f3c4921605041c776b2db93e2c0cd750ea9713562357e",
+    "vendor/volatility3/volatility3/framework/symbols/windows/poolheader-x86.json": "2385f299dd2c8736da34489f1fec95bd09d2592a0bd8c1e600bd3fa0a9601385",
+    "vendor/volatility3/volatility3/framework/symbols/windows/registry.json": "46701ac06eaa14a153c29d4d4cfeecaeeaa65b39165c90eab4461ca1b28945f7",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-vista-x64.json": "a5931214d1c53efadaa0709958c8f38e0e9c4024b4b12c04a888c1d424ac83d3",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-vista-x86.json": "8693212d85943179553102b6e73278456911955ea60df9c86e8ccaa3bf949d83",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-win10-15063-x64.json": "201f5641a0d9bcb1705cb8dfb074b353e202e462a7dd079a6416d69a63e8fa25",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-win10-15063-x86.json": "c20270122d552c06fd0546786d46aa535080e5ecb2f64284409c5ff8a03ff4c8",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-win10-16299-x64.json": "cc5abae66536772b7be649a82257ae7c01dced27f2c14e911eba2157cff3655d",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-win10-16299-x86.json": "7208464cc7da18aa6a3a2e4e06d19cbf413ce4599f1ff155ba41dd175e61d07f",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-win10-17763-x86.json": "8ff3a37e43032d91ea17e6d1188b1a8ca240862b593f9215585be168a2dc743e",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-win10-18362-x64.json": "13f5172b3a2b34b8ffc0ac28bda6404e21c138cf5197a47565961e80f45d218b",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-win10-18362-x86.json": "cfd01e967161d959040bb76c4bb917ff537f3f6d59bee767edd6fb4200eabeb9",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-win10-19041-x64.json": "affc489520542f368f7265f0f081f96ea06cafe80fdcf987fdddcab9b0fc75ac",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-win10-19041-x86.json": "18f8f6a9e15789aee2b2223a493a3a359ff9e18444615e0bc3b74b7ddac2b3ef",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-win10-25398-x64.json": "e7be41b450f172bc4082d2f7f58e881ad776dbf3ec842af5ba013c20955469b8",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-win8-x64.json": "8dfb4e070a4fa72fc314b601759aa0e256f4314736e0545584167fcca40c3010",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-win8-x86.json": "8a65c3622e804a94b06cb836f7170ceb8d1e9d7aeacf1a31e1ca463d0fe83224",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-xp-2003-x64.json": "cb88cf45fc7b6d09c744d19eea8dfc77a78e07f208d46d19e946a4a2bc7650a6",
+    "vendor/volatility3/volatility3/framework/symbols/windows/services/services-xp-x86.json": "f2b5a552f63813193871ec344ab79e95cf1eb5e4b0c191386734cc36231519a6",
+    "vendor/volatility3/volatility3/framework/symbols/windows/shimcache/shimcache-2003-x64.json": "adbb60490f8cc75d454e7a294ab2718cdafdb46331e9ced1add54e3e9c8e328a",
+    "vendor/volatility3/volatility3/framework/symbols/windows/shimcache/shimcache-2003-x86.json": "d0866e9fdec58d9c8d7cd0b59414e448c8352f843ea9da328775c9a084750680",
+    "vendor/volatility3/volatility3/framework/symbols/windows/shimcache/shimcache-vista-x64.json": "b1521af0b06705c23ffbbc47112cd1e4d728787d0280a034cf932d3ef939b9ee",
+    "vendor/volatility3/volatility3/framework/symbols/windows/shimcache/shimcache-vista-x86.json": "8af230402ef0701d3b6680c01f18243dc58017a29224ff2e4630c88b9906924e",
+    "vendor/volatility3/volatility3/framework/symbols/windows/shimcache/shimcache-win10-x64.json": "d24bd939fa47c12da21ba1ddcf212208a180d3f9aab489ee074abdb3c74ce6bc",
+    "vendor/volatility3/volatility3/framework/symbols/windows/shimcache/shimcache-win10-x86.json": "637b210ba8912a143f9489e341f479d42ea9ebdbcb8f456ba2f13a4e4ccbbd5c",
+    "vendor/volatility3/volatility3/framework/symbols/windows/shimcache/shimcache-win7-x64.json": "c5419ce783c2779f33117a37ef33f69a67d79ae8e812d1281303b3540645c4ed",
+    "vendor/volatility3/volatility3/framework/symbols/windows/shimcache/shimcache-win7-x86.json": "84b4b060f29873293429d02aebfe3eaff47c1c31a14170d7221149eb567737d0",
+    "vendor/volatility3/volatility3/framework/symbols/windows/shimcache/shimcache-win8-x64.json": "42433dfdaff4cb7963e9166c6952d5bd0feed89ead9a0e6020367540d7315fad",
+    "vendor/volatility3/volatility3/framework/symbols/windows/shimcache/shimcache-win8-x86.json": "ce4312ab5bb1dc53e70ab5d9d243ef2d77f216c9a9d42a8772ab3118c95e7834",
+    "vendor/volatility3/volatility3/framework/symbols/windows/shimcache/shimcache-xp-sp2-x86.json": "155b807ac6b188ca3b2055d5d61eba0771fe31547c03d14856e6123dfe24ea05",
+    "vendor/volatility3/volatility3/framework/symbols/windows/shimcache/shimcache-xp-sp3-x86.json": "68e7ef06e0eab1a625a66be2b7696b157acc7ebcce6134dd4953e3a5af92652d",
+    "vendor/volatility3/volatility3/framework/symbols/windows/unloadedmodules-x64.json": "741d9b053d6f7f411439bddc49008f04e0b1a6dbfcc14b29c9fd78e7b2d862ca",
+    "vendor/volatility3/volatility3/framework/symbols/windows/unloadedmodules-x86.json": "44b7d82c6dc3bcc536cae42dd421315d6c1978ee4e84b717e511df6a6afae437",
+    "vendor/volatility3/volatility3/framework/symbols/windows/versions.py": "7d1be83acd4b80ad7f79f0eb6d178776dafeecdd80f61d67587865ae932cc349",
+    "vendor/volatility3/volatility3/framework/symbols/windows/wow64.json": "24332ab370887e7534770ad22816098610a521cf105ff7f41462f33685a38a32",
+    "vendor/volatility3/volatility3/framework/symbols/wrappers.py": "2588198840a4d7a19586895757904dd81aafc27696cfeabc28efa3566f677851",
+    "vendor/volatility3/volatility3/plugins/__init__.py": "411b8b12e2bc94b5a7a7fc6ffffd4a7e0b96a294087be6e26232ecc4031c61f8",
+    "vendor/volatility3/volatility3/plugins/linux/__init__.py": "a19538242c804fb24afcc90abec4cca7f806339bb01137d9efc980640ec4dacd",
+    "vendor/volatility3/volatility3/plugins/mac/__init__.py": "27f00c43e5d8e06c4c4b694faf94514b08c2ef64739fa828646c2981e11d582d",
+    "vendor/volatility3/volatility3/plugins/windows/__init__.py": "9b2965362290fae62b986ce6f27507dd639dc590b85ac963e179ee524930bcc0",
+    "vendor/volatility3/volatility3/plugins/windows/registry/__init__.py": "c28ef3170f09f30b9845c281cb98f49cc446aec248eebefa085da71a6cd0911c",
+    "vendor/volatility3/volatility3/plugins/windows/registry/certificates.py": "c7a781d9fe36be0f5874c2eeb30b9272643658260d00f056b433774094b867bd",
+    "vendor/volatility3/volatility3/plugins/windows/statistics.py": "d938781bd353bd72f9550011c70cd159c6522a1d51adf40f5e2f220860d235be",
+    "vendor/volatility3/volatility3/schemas/__init__.py": "8aa438a94638a2cfbae9816472ead14390549df84f1185efe2c1d136aced93af",
+    "vendor/volatility3/volatility3/schemas/schema-0.1.0.json": "1c0e0612bcf64c9cde4d0b4f8ad988f55e3895818f6d3f312c06848bab4074d9",
+    "vendor/volatility3/volatility3/schemas/schema-2.0.0.json": "f575c8ce1d8e7986571ba087239c89df91c487f3e70e31d51c1964ce053ed18c",
+    "vendor/volatility3/volatility3/schemas/schema-2.1.0.json": "1f0c15a20b6ab2c1e623dad7f9286e7b33c19a52c674697bcb4ae303b7c1e715",
+    "vendor/volatility3/volatility3/schemas/schema-4.0.0.json": "ea74ed9174abeb6c7f14d66f01badf3d1b4a483fdcbd10317b5a2a092a16e0e2",
+    "vendor/volatility3/volatility3/schemas/schema-4.1.0.json": "2c11ca962964432c61bdee0fefa71f0e1dbef42a840d8c17531a6d0a0ced1a42",
+    "vendor/volatility3/volatility3/schemas/schema-6.0.0.json": "75509285d74c3840fc12ad781fca9933845b89ccb3dd6520e92e0b57694ff0e4",
+    "vendor/volatility3/volatility3/schemas/schema-6.1.0.json": "210d49ec438ce9d661256f72376c9a17f5ea477c39e44436f230f192fd436c02",
+    "vendor/volatility3/volatility3/schemas/schema-6.2.0.json": "39386442c722598f55213399b1bc603b49c7ecd43ecf58c2f110a97624da5246",
+    "vendor/volatility3/volatility3/schemas/schema-6.3.0.json": "6e5a1b011e5f82824f00e7b2eb312ba41527fe979561e949fc40f539a57675eb",
+    "vendor/volatility3/volatility3/symbols/__init__.py": "71310a7d0a5d6aa2a7be2ff8988ad74b049c0b146bdaa4f5bcc8e2e07bbde454",
+    "vendor/volatility3/volatility3/symbols/generic/vmcs/haswell-architecture.json": "5e0a496ea56b9968f09c432669cc6a2b80e895f79bde1b9ecb1d14c543ded577",
+    "vendor/volatility3/volatility3/symbols/generic/vmcs/nehalem-architecture.json": "aced0933ed33a4f2608805c764902b1bcf6d369244c2d856bafa07c00aa35174",
+    "vendor/volatility3/volatility3/symbols/generic/vmcs/sandybridge-architecture.json": "f7aa42ad22804cf5411d3df0920176416b6c30b393769d968a2b4b02a950d88a",
+    "vendor/volatility3/volatility3/symbols/generic/vmcs/skylake-architecture.json": "a89ba92114c09ad4974e0abdf083037843a3d6a53ed461b0f1c0f454d1127250",
+    "vendor/volatility3/volatility3/symbols/generic/vmcs/westmere-architecture.json": "82527b992e2707a948f45f27016b13d1c0eeb98f3224898a02cfed842eec17d6"
+  },
+  "mutable": [
+    "vendor/volatility3/volatility3/framework/plugins/windows/callbacks.py",
+    "vendor/volatility3/volatility3/framework/plugins/windows/dumpfiles.py",
+    "vendor/volatility3/volatility3/framework/plugins/windows/poolscanner.py",
+    "vendor/volatility3/volatility3/framework/plugins/windows/psxview.py"
+  ],
+  "schema_version": "tbench.pristine_env_manifest.v1"
+}

tasks/candidate-0308-security-forensics/tests/fixtures/repair_contract.json

@@ -0,0 +1,6 @@
+{
+  "schema_version": "volatility-repair-report.v1",
+  "modules": ["callbacks", "dumpfiles", "poolscanner", "psxview"],
+  "handles_requirement": [4, 0, 0],
+  "context_methods": ["get_type_map", "find_cookie", "handles"]
+}

tasks/candidate-0308-security-forensics/tests/task_test.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+set -euo pipefail
+mkdir -p /logs/verifier
+set +e
+# tbench-anti-hack-guard:v1
+export PYTHONNOUSERSITE=1
+export PYTHONDONTWRITEBYTECODE=1
+# Fail open when the verifier image has no python3 (node-only tests images are
+# excluded from the RL set but still verifiable natively): a missing
+# interpreter must not swallow the grader's own reward write.
+if command -v python3 >/dev/null 2>&1 && [ -f /tests/anti_hack_guard.py ]; then
+  if ! python3 /tests/anti_hack_guard.py; then
+    # Guard already wrote reward=0; the reward file is the grading contract.
+    exit 0
+  fi
+fi
+
+
+python3 -m pytest --ctrf /logs/verifier/ctrf.json -q /tests/test_outputs.py
+status=$?
+set -e
+if [ "$status" -eq 0 ]; then printf '1\n' > /logs/verifier/reward.txt; else printf '0\n' > /logs/verifier/reward.txt; fi
+exit "$status"