agent-hitch 0.2.9 → 0.2.10

package/README.zh-CN.md

@@ -1,196 +1,270 @@
+<div align="center">
+
 # Hitch
 
+### 模型与智能体评测的统一执行层
+
 [![npm version](https://img.shields.io/npm/v/agent-hitch.svg)](https://www.npmjs.com/package/agent-hitch)
 [![GitHub release](https://img.shields.io/github/v/release/rsi-gear/agent-hitch)](https://github.com/rsi-gear/agent-hitch/releases)
+[![License](https://img.shields.io/badge/license-Apache--2.0-green)](LICENSE)
 [![Discord](https://img.shields.io/badge/Discord-加入讨论-5865F2?logo=discord&logoColor=white)](https://discord.gg/cZ4NBbHDk)
 
-[English](README.md) | [简体中文](README.zh-CN.md)
+[English](README.md) | 简体中文
 
-**让智能体 Harness 的每次运行都可复现。**
+**[User Guide · 用户指南](https://rsigear.xyz/docs/hitch/zh/) · [Quick Start](#quick-start快速开始) · [工作原理](#工作原理) · [Hitch 与 Harbor](#hitch-与-harbor) · [并行与恢复](#并行执行与恢复)**
 
-Hitch 可以从确定的软件版本或 Git 提交运行 Codex、Claude Code、Pi、OpenCode
-和 DeepSeek Harness。每次运行都会关联 Harness 版本、不可变制品、工作区、
-轨迹、日志和评测证据。
+</div>
 
-```text
-版本或提交 -> 不可变制品 -> 运行或评测 -> 可验证证据
-```
+评测模型与智能体 Harness，需要协调镜像构建、沙箱、Harness 版本、模型端点、
+失败重试和证据采集。实验开始并行、扩展到多台机器后，这些工作也随之增加。
 
-```bash
-npm install --global agent-hitch
+**Hitch 统一管理从任务定义到可验证结果包的执行流程。** 提交 Harbor 兼容任务，
+选择模型与 Harness，Hitch 负责准备、调度、执行和结果收集。固定 Harness 比较
+模型，或固定模型比较 Harness。
 
-hitch run \
-  --harness codex@version:0.92.0 \
-  --prompt "Inspect this repository"
-```
-
-> **状态：** pre-alpha。核心运行、来源追踪、轨迹、反馈、守护进程和 Harbor
-> 评测链路已经实现。
-
-## 为什么使用 Hitch？
+- [x] **构建与缓存。** 固定 Harness 版本，复用已验证的制品与环境镜像。
+- [x] **适配 Harness。** 通过统一接口运行 Codex、Claude Code 等受支持的 Harness。
+- [x] **接入模型。** 使用云端 API，或托管的本地与远程 SGLang 推理。
+- [x] **分配执行节点。** 在本机 Docker 或已注册的远程 Worker 上运行任务沙箱。
+- [x] **并行与恢复。** 共享资源预算、并行执行 Trial，在支持的恢复路径中保留已完成工作。
+- [x] **收齐结果证据。** 分数、轨迹、Verifier 证据与来源信息归入同一份结果包。
 
-Git 告诉你哪些源码发生了变化，Hitch 则告诉你究竟运行了什么，以及它产生了
-哪些证据。
+> **状态：** pre-alpha。以下能力对应当前 `dev`；配置与支持范围见
+> [User Guide](https://rsigear.xyz/docs/hitch/zh/)。
 
-- **复现：** 从确定的软件包版本或源码提交重新运行。
-- **比较：** 通过统一的执行契约比较不同 Harness 和模型。
-- **审计：** 用不可变制品、原生事件、规范化轨迹、日志、反馈和评测记录验证
-  结果。
+## Quick Start：快速开始
 
-Hitch 适合构建智能体评测、Harness 实验、Coding Agent 基础设施和自动晋级
-流水线的团队。
+需要 **Node.js 22+**、Git 和模型访问权限。本地运行不需要 Docker。
 
-## 快速开始
-
-Hitch 要求 Node.js 22 或更高版本。
+**1. 安装 Hitch，并完成 Harness 认证。** 示例固定了一个 Codex 版本，
+继续前先完成登录流程。
 
 ```bash
-npm install --global agent-hitch
-hitch --version
+npm install --global agent-hitch@0.2.10
+npx --yes @openai/codex@0.92.0 login
 ```
 
-在隔离的 Git worktree 中运行一个确定的 Harness 版本：
+**2. 从干净的 Git 仓库运行。** Worktree 模式要求 `git status --short` 没有
+输出。要包含当前未提交的文件，可以选择
+[`--workspace-mode copy`](docs/guide/zh-CN/versions-and-workspaces.md)。
 
 ```bash
+git status --short
 hitch run \
   --harness codex@version:0.92.0 \
   --workspace-mode worktree \
-  --prompt "Inspect this repository" \
-  --output jsonl
+  --prompt "总结这个仓库及其测试命令，不修改文件。" \
+  --timeout 5m \
+  --output json
 ```
 
-输出中包含 run ID。自动化消费者应使用有界的轨迹和 verifier 视图，完整轨迹
-inspect 仅用于显式审计：
+**3. 检查运行结果。** 用返回的 `run_id` 替换 `RUN_ID`。确认状态、退出码和
+回答，再查看已捕获的轨迹。
 
 ```bash
+hitch runs inspect RUN_ID --json
 hitch trajectory project RUN_ID --profile analysis --json
-hitch trajectory events RUN_ID --types tool/call,tool/result --limit 100 --json
-hitch trajectory inspect RUN_ID
-hitch verifier inspect RUN_ID --json
 ```
 
-`project` 会重建 DSH surface，并按请求 attempt 合并流式 chunk，使 retry 及其
-finish reason 保持独立；`events` 在源端完成过滤和分页。
-使用 `--field` 钻取字段时，还必须传入任一有界视图返回的 `canonical_sha256`。
-对于没有固定 canonical SHA-256 的旧版 trajectory ref，流式视图会 fail closed。
-使用 `--json` 调用的命令失败时，会在 stderr 返回稳定的 JSON 错误 envelope。
+记录保存在 `~/.hitch/runs/RUN_ID/`。托管工作区会被保留，Hitch 不会自动把
+智能体修改合并回源码仓库。认证方式、模型选择和并行提交示例见
+[完整 Quick Start](https://rsigear.xyz/docs/hitch/zh/quickstart)。
+
+## 工作原理
+
+```mermaid
+flowchart LR
+    tasks["Harbor 兼容任务<br/>模型 + Harness"] --> prepare
+    subgraph hitch["Hitch 执行层"]
+        prepare["构建与缓存<br/>Harness 适配"] --> execute["任务沙箱<br/>调度与恢复"]
+        execute <--> access["模型接入<br/>可选的交互采集"]
+    end
+    access <--> models["云端 API<br/>本地 / 远程 SGLang"]
+    execute --> bundle["结果包<br/>轨迹 · Verifier 证据 · 来源信息"]
+    access -.-> bundle
+    bundle -.-> candidate["训练数据候选<br/>可选导出"]
+```
 
-每次运行的 manifest、结果、事件、日志和轨迹都会保存在
-`~/.hitch/runs/RUN_ID` 下。
+CLI 与 daemon HTTP API 使用同一执行层。任务定义指令、环境和 Verifier；
+Hitch 管理准备、执行与证据发布。每份结果包关联实际使用的 Harness 版本、
+模型身份、环境镜像和执行记录。
 
-## 固定任意 Harness 版本
+模型交互采集取决于 Harness、端点和采集策略。训练数据候选保留可用性判定
+和来源信息，供下游审核。
 
-每次运行都会显式选择 Harness：
+[构建与缓存](docs/environment-images.md) ·
+[执行与证据契约](docs/hitch-harbor-control-plane-implementation-status.md)
 
-```bash
-# 对本机已经安装的可执行文件生成指纹并运行。
-hitch run --harness codex@installed --prompt "Inspect this repository"
+## Hitch 与 Harbor
 
-# 解析并运行一个确定的已发布版本。
-hitch run --harness codex@version:0.92.0 --prompt "Inspect this repository"
+Hitch 采用 **Harbor 的任务定义格式**，接入已有 Benchmark 和自定义任务。
+[Benchmark Package](docs/benchmark-packages.md) 定义任务输入、工具、生命周期
+与评分规则；Hitch 管理实验版本、执行编排、故障恢复和结果。
 
-# 从已注册的上游仓库构建并运行一个确定的提交。
-hitch run --harness codex@commit:0123456789abcdef --prompt "Inspect this repository"
-```
+| 能力 | Harbor CLI | Hitch |
+| --- | :---: | :---: |
+| **跨评测共享资源预算** | — | ✅ |
+| **跨评测公平调度** | — | ✅ |
+| **控制进程崩溃后接管存活 Trial** | — | ✅ |
+| 并行 Trial、失败重试与重新评分 | ✅ | ✅ |
+| 中断评测续跑 | ✅ | ✅ |
 
-| Harness | 已安装版本 | 确定的软件包版本 | 源码提交 |
-| --- | :---: | :---: | :---: |
-| Codex | ✓ | ✓ | ✓ |
-| Claude Code | ✓ | ✓ | — |
-| Pi | ✓ | ✓ | ✓ |
-| OpenCode | ✓ | ✓ | — |
-| DeepSeek Harness | ✓ | ✓ | ✓ |
+对比本机 CLI 工作流。**—** 表示需要额外的协调层。
+公平调度要求任务成员已知；存活执行接管要求 POSIX 和完整执行证据。
+[支持范围 →](docs/guide/zh-CN/daemon.md)
+
+<details>
+<summary>验证记录与对比范围</summary>
 
-确定的版本和提交会被准备为经过验证、采用内容寻址的制品，并从 Hitch 的本地
-缓存中复用。已安装的可执行文件适合本地工作；需要可移植性时，应使用不可变
-引用。
+2026-09-01 的离线 Harbor 验收记录包含 20 个 Trial、1 次环境构建、19 次缓存
+命中和 0 次 OOM。这验证了该负载下的缓存复用与资源准入，不是与原生 Harbor
+的速度或成本对照实验。
+[验收记录](docs/hitch-harbor-control-plane-implementation-status.md) ·
+[Harness 构建复用](docs/evals.md)
 
-## 每次运行都会留下证据
+[Harbor 评测](https://www.harborframework.com/docs/run-jobs/run-evals) ·
+[Harbor 重试与恢复](https://github.com/harbor-framework/harbor/blob/main/src/harbor/cli/jobs.py) ·
+[Harbor 重新评分](https://www.harborframework.com/docs/run-jobs/regrade) ·
+[Hitch 调度与恢复](docs/daemon.md)
 
-Hitch 记录从请求到结果的完整链路：
+</details>
 
-- 请求的引用及解析后的不可变版本；
-- 经过验证、采用内容寻址的可运行制品；
-- 工作区、模型身份、生命周期与最终结果；
-- 规范化控制面事件与原始进程日志；
-- 支持场景下经过脱敏的 provider-native 事件；
-- 采用 SHA-256 绑定文件、兼容 DSH 的规范化轨迹；
-- 带版本的消息反馈，以及有界的 verifier/评测证据。
+## 本地与远程模型推理
 
-可以通过 CLI 查询运行，并在不改写轨迹的情况下附加反馈：
+当前 `dev` 已包含托管推理。完整的 Hugging Face safetensors checkpoint 只需导入一次，此后继续使用原有
+run/eval 命令，并把模型写成 `local/<name>`。Hitch 会自动选择固定摘要的 CPU 或
+CUDA preview runtime、按需启动 daemon 和 SGLang 服务，并记录不可变的模型、runtime
+和 inference 身份。
 
 ```bash
-hitch runs list --json
-hitch verifier inspect RUN_ID --json
-hitch feedback list RUN_ID --json
-hitch feedback put RUN_ID \
-  --message MESSAGE_ID \
-  --rating positive \
-  --note "修改保持了足够聚焦"
+hitch models add /models/coder-checkpoint --name coder
+
+hitch run \
+  --harness codex@version:0.145.0 \
+  --model local/coder \
+  --prompt "Inspect this repository"
 ```
 
-带版本的机器接口 Schema 位于 [`docs/schemas`](docs/schemas)。
+本机预览面向 Linux/amd64 Docker，以及 Intel Xeon AMX CPU 或兼容的单张
+NVIDIA CUDA GPU。托管 Codex 要求上述确定版本及受支持的模型工具解析器；
+不支持的硬件不会回退到云模型。
+
+远程推理可以通过 Harness 的模型 API 配置接入，也可以注册托管模型节点。
+节点模型仍使用 `local/<name>`，由绑定选择远程 GPU 主机。配置、Docker 访问、
+并行容量与服务恢复见[模型推理指南](https://rsigear.xyz/docs/hitch/zh/model-inference)。
 
-## 可复现的智能体评测
+## 并行执行与恢复
 
-Hitch 集成了 [Harbor](https://github.com/harbor-framework/harbor)，可以在 Docker
-中评测确定且可移植的 Harness 版本：
+提交一次，用同一个 Eval ID 跟踪执行与恢复。
+
+- [x] 多个评测共享 CPU、内存和 GPU 预算。
+- [x] 任务槽位释放后，小评测也能获得调度机会。
+- [x] Daemon 崩溃后接管受支持的存活 Trial。
+- [x] 补收已完成结果，继续未启动任务。
+- [x] 只修复选中的失败，保留有效结果。
+
+存活进程接管要求 POSIX 和完整的执行证据；普通 Harness Run 不会在 daemon
+崩溃后自动续跑。
+
+[配置、示例与恢复边界 →](https://rsigear.xyz/docs/hitch/zh/daemon)
+
+## 评测模型与 Harness
+
+- [x] **比较模型：** 固定 Harness、任务和评测配置，更换模型。
+- [x] **比较 Harness：** 固定模型和任务，更换 Harness 或其版本。
+- [x] **无工具模型评测：** 对兼容的 Benchmark 任务使用可信的 `model-call` 驱动。
+
+当前执行后端为 Harbor。下面的 Docker 示例需要 Python 3.12+、运行中的
+Docker daemon，以及容器能够使用的模型认证。自定义任务和驱动要求见
+[Benchmark Package](docs/benchmark-packages.md)。
 
 ```bash
 hitch eval setup harbor
 hitch eval doctor
-
-hitch eval run \
-  --backend harbor \
-  --dataset terminal-bench@2.0 \
-  --harness codex@version:0.92.0 \
-  --model openai/gpt-5.6
 ```
 
-每次评测都会关联已解析的 Harness 版本、采用内容寻址的 Hitch 控制器运行时、
-后端配置、奖励、日志和轨迹证据。安装方法和可移植性规则参见
-[Harbor 智能体评测](docs/evals.md)。
+先按[单任务评测教程](https://rsigear.xyz/docs/hitch/zh/evaluations)运行附带的
+[Hello Hitch 任务](docs/guide/examples/hello-hitch)，完成容器认证、执行和结果
+检查，再扩展到大型 Benchmark。若 Hitch daemon 已占用状态目录，按指南使用
+`hitch eval run --daemon` 或 `hitch eval submit`。
+
+每个 Trial 发布一个 Hitch Run，关联模型身份、Harness 版本、控制器运行时、后端配置、
+奖励、日志和轨迹。有效零分与无效 observation 会分别处理。Benchmark、资源和
+可移植性契约见 [Harbor 参考](docs/evals.md)。
+
+## 支持的 Harness
+
+| Harness | 已安装的可执行文件 | 确定的软件包版本 | 源码提交 |
+| --- | :---: | :---: | :---: |
+| Codex | ✓ | ✓ | ✓ |
+| Claude Code | ✓ | ✓ | — |
+| Pi | ✓ | ✓ | ✓ |
+| OpenCode | ✓ | ✓ | — |
+| DeepSeek Harness | ✓ | ✓ | ✓ |
 
-## 为自动化而设计
+使用 `codex@installed` 运行本机程序，使用 `codex@version:0.92.0` 选择确定的
+软件包版本，或把真实上游提交填入 `codex@commit:COMMIT`。评测要求可移植的
+版本或提交引用。引用选择、制品准备和工作区模式见
+[固定版本与隔离工作区](docs/guide/zh-CN/versions-and-workspaces.md)。
 
-- 提供 JSON 和 JSONL 输出、带版本的 Schema 与类型化错误
-- 支持直接执行或具有并发上限的持久化守护进程
-- 支持共享、detached Git worktree 和独立副本工作区
-- 支持超时、取消、进程树清理和中断运行恢复
-- 通过 `--root <path>` 或 `HITCH_ROOT` 隔离本地状态
+## User Guide · 用户指南
 
-需要长期执行队列时，可以启动守护进程：
+**[在线阅读用户指南](https://rsigear.xyz/docs/hitch/zh/)**，也可以查看
+[仓库中的同一份 Markdown](docs/guide/zh-CN/index.md)。
 
-```bash
-hitch daemon start --max-concurrent 4
-hitch run --daemon --harness codex@version:0.92.0 --prompt-file task.md
-```
+| 指南 | 你会学到什么 |
+| --- | --- |
+| [Quick Start](docs/guide/zh-CN/quickstart.md) | 安装、认证、运行任务并提交并行工作 |
+| [本地与远程模型推理](docs/guide/zh-CN/model-inference.md) | 接入远程 API、托管本机 SGLang 和远程模型节点 |
+| [固定版本与隔离工作区](docs/guide/zh-CN/versions-and-workspaces.md) | 固定可执行版本，选择 worktree、copy 或 shared 模式 |
+| [查看运行与证据](docs/guide/zh-CN/runs-and-evidence.md) | 查询结果、轨迹、Verifier 证据和消息反馈 |
+| [第一次评测](docs/guide/zh-CN/evaluations.md) | 运行小型 Docker 任务，理解有效与无效结果 |
+| [Daemon：并行与恢复](docs/guide/zh-CN/daemon.md) | 配置资源预算、共享容量并恢复中断的评测 |
+| [日常运行与排错](docs/guide/zh-CN/operations.md) | 查看队列、取消任务、选择状态目录并诊断失败 |
+| [CLI 命令参考](docs/guide/zh-CN/cli-reference.md) | 查询全部命令、参数、筛选条件和集成入口 |
 
-## 文档
+<details>
+<summary><strong>技术参考与平台说明</strong></summary>
 
 - [设计与架构](docs/design.md)
+- [Benchmark Package 与任务协议](docs/benchmark-packages.md)
 - [Harbor 评测](docs/evals.md)
 - [Verifier evidence](docs/verifier-evidence.md)
 - [工作区隔离](docs/workspaces.md)
-- [守护进程设计](docs/daemon.md)
+- [Daemon 设计](docs/daemon.md)
+- [带版本的机器接口 Schema](docs/schemas)
 - [Hitch 0.2 开发规范](docs/hitch-0.2-development-spec.md)
 - [发布流程](docs/releasing.md)
+- [贡献指南](CONTRIBUTING.md)
 
-## 项目状态
+自动化流程可以使用 JSON/JSONL 输出、类型化错误、有界证据查询、超时、取消和
+进程树清理。通过 `--root` 或 `HITCH_ROOT` 选择独立状态目录，并在所有命令中
+保持一致。
+
+Windows 已覆盖 Node 22 和 24，包括 npm/Agent 的 `.cmd` 包装程序以及软件包
+Harness 缓存和完整性校验。Daemon 硬崩溃后的本地存活 Harbor 进程接管仅支持 POSIX。
 
-Hitch 是 pre-alpha 阶段的本地版本与证据层。它是 Git 的补充，目前不提供远端
-制品注册表、分支、标签、候选晋级或回滚策略。
+GPU Harbor Trial 需要兼容的 Docker 主机，以及显式的 `--capacity-gpus` 和
+`--eval-gpus` 参数；Hitch 不会猜测 GPU 容量。维护者可以在兼容的自托管 Runner
+上运行 `NVIDIA GPU hardware canary` 工作流。
+
+</details>
+
+## 项目状态
 
-远端制品同步、命名候选、晋级记录和更多 Harness 适配器已列入计划。
+Hitch 是 pre-alpha 阶段的模型与 Harness 评测执行层。远端制品同步、命名候选、晋级记录
+和更多 Harness 适配器已列入计划。它是 Git 的补充，目前不提供远端制品注册表、
+分支、标签、候选晋级或回滚策略。
 
 ## 社区
 
-加入 [Hitch Discord 社区](https://discord.gg/cZ4NBbHDk)，提问、分享反馈，
-并讨论智能体 Harness 基础设施。
+加入 [Discord](https://discord.gg/cZ4NBbHDk)，提问、分享反馈，并讨论模型与
+智能体评测基础设施。
 
-Hitch 的设计受到 [Multica](https://github.com/multica-ai/multica) 启发，并使用
-[Harbor](https://github.com/harbor-framework/harbor) 作为评测后端。
+Hitch 的设计受到 [Multica](https://github.com/multica-ai/multica) 启发，采用
+[Harbor](https://github.com/harbor-framework/harbor) 的任务定义格式，并集成
+[SGLang](https://github.com/sgl-project/sglang)，提供托管的本地与远程模型推理支持。
 
 ## 许可证
 
-本项目采用 [Apache License 2.0](LICENSE) 许可证。
+[Apache License 2.0](LICENSE)。

package/dist/scripts/canary-native-training.js

@@ -0,0 +1,221 @@
+import assert from "node:assert/strict";
+import { remoteCanaryWorker } from "./canary-worker-host.js";
+import { spawn } from "node:child_process";
+import { createWriteStream } from "node:fs";
+import { mkdir, mkdtemp, readFile, readdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { DaemonServer, daemonClient } from "../src/daemon/index.js";
+import { readExecutionLeases, reapOwnedDockerResources, runEval, validateEvalId } from "../src/evals/index.js";
+import { parseTrainingBinding } from "../src/model-access/index.js";
+import { atomicWriteJSON, runCommand, sha256JSON, statePaths } from "../src/foundation/index.js";
+// Real Harbor/Docker and public worker CLI against a separately supervised native gateway.
+// The node independently verifies exact receipts; neither script certifies a training runtime.
+const python = process.env.HITCH_HARBOR_TEST_PYTHON;
+const image = process.env.HITCH_TRAINING_CANARY_IMAGE;
+assert.ok(python && image, "Set HITCH_HARBOR_TEST_PYTHON and HITCH_TRAINING_CANARY_IMAGE (local bash-capable image)");
+const harbor = path.join(path.dirname(python), "harbor");
+const cli = path.resolve("dist/bin/hitch.js");
+const root = await mkdtemp(path.join(tmpdir(), "hitch-native-remote-training-"));
+const externalFile = process.env.HITCH_NATIVE_CANARY_BINDING;
+const output = process.env.HITCH_NATIVE_CANARY_OUTPUT;
+const taskInputFile = process.env.HITCH_NATIVE_CANARY_TASK_INPUT;
+assert.ok(taskInputFile, "Set HITCH_NATIVE_CANARY_TASK_INPUT");
+const taskInput = JSON.parse(await readFile(taskInputFile, "utf8"));
+assert.equal(taskInput.kind, "native-diagnostic-task-input");
+assert.equal(typeof taskInput.instruction, "string");
+assert.ok(externalFile && output, "Set HITCH_NATIVE_CANARY_BINDING and HITCH_NATIVE_CANARY_OUTPUT");
+await mkdir(output, { recursive: true });
+const external = JSON.parse(await readFile(externalFile, "utf8"));
+const binding = parseTrainingBinding(external.binding);
+const secret = external.credential;
+const endpoint = new URL(external.base_url);
+assert.equal(endpoint.protocol, "http:");
+assert.equal(endpoint.hostname, "127.0.0.1");
+assert.equal(endpoint.pathname, "/v1");
+assert.match(secret, /^[a-f0-9]{64}$/);
+const controllerRoot = path.join(root, "controller"), workerRoot = path.join(root, "worker");
+const privateRoot = path.join(root, "private"), dataset = path.join(root, "dataset");
+await mkdir(privateRoot, { recursive: true, mode: 0o700 });
+const resource = { cpu_millis: 1000, memory_bytes: 1024 ** 3, container_slots: 1, build_slots: 0 };
+const zero = { cpu_millis: 0, memory_bytes: 0, container_slots: 0, build_slots: 0 };
+const env = { ...process.env, HITCH_HARBOR_PYTHON_PATH: python };
+delete env.HITCH_TEST_HOST_ARTIFACT_BUILDER;
+const imageInfo = await runCommand("docker", ["image", "inspect", image, "--format", "{{json .}}"], { timeoutMs: 10_000 });
+const inspected = JSON.parse(imageInfo.stdout);
+assert.match(inspected.Id, /^sha256:[a-f0-9]{64}$/);
+assert.equal(inspected.Id, taskInput.image_id);
+assert.equal(`${inspected.Os}/${inspected.Architecture}`, "linux/amd64");
+const version = (await runCommand(python, ["-c", 'import importlib.metadata; print(importlib.metadata.version("harbor"))'], { timeoutMs: 10_000 })).stdout.trim();
+assert.equal(version, "0.21.0");
+const localEngine = (await runCommand("docker", ["info", "--format", "{{.ID}}"], { timeoutMs: 10_000 })).stdout.trim();
+const remoteWorker = await remoteCanaryWorker(root, workerRoot);
+const workerObservation = await remoteWorker?.observe(inspected.Id, localEngine);
+const engine = workerObservation?.engine ?? localEngine;
+const server = new DaemonServer({ root: controllerRoot, port: 0, maxConcurrent: 1,
+    resourceCapacity: { ...resource, build_slots: 1 }, evalTrialResources: resource,
+    evalExecutor: options => runEval({ ...options, harborExecutable: harbor, env }), logger: () => { } });
+let worker;
+let workerDone;
+const workerLog = createWriteStream(path.join(root, "worker.log"));
+let evalId;
+let passed = false;
+const summary = { kind: "native-harbor-training-transport-diagnostic", validated_gpu: false, worker_host: remoteWorker ? "ssh" : "local-process", root, harbor: version, image_id: inspected.Id, docker_engine_digest: sha256JSON(engine) };
+console.log(JSON.stringify({ event: "canary-start", root, image_id: inspected.Id }));
+try {
+    const harness = await prepareInputs();
+    await server.start();
+    const registration = { schema_version: "1", worker_id: "worker_real_training", provider: "remote-docker",
+        collision_domain_id: `docker-engine:${engine}`, platforms: ["linux-x64"], backends: [{ id: "harbor", version }],
+        features: { docker: true, buildkit: true, model_proxy: true, isolated_same_task_attempts: false, training_external_binding: "2" },
+        task_membership: ["known"], capacity: { total: resource, reserved_for_system: zero, allocatable: resource } };
+    const registrationFile = path.join(privateRoot, "registration.json"), credentialFile = path.join(privateRoot, "worker-credential.json");
+    const bindingFile = path.join(privateRoot, "binding.json");
+    await atomicWriteJSON(registrationFile, registration);
+    await atomicWriteJSON(bindingFile, { schema_version: "1", binding, base_url: external.base_url, credential: secret });
+    await runCommand(process.execPath, [cli, "--root", controllerRoot, "training", "register", "--file", bindingFile], { env, timeoutMs: 10_000 });
+    const baseUrl = `http://127.0.0.1:${server.port}`;
+    await runCommand(process.execPath, [cli, "worker", "register", "--server", baseUrl, "--registration", registrationFile,
+        "--admin-token-file", statePaths(controllerRoot).token, "--credential-file", credentialFile], { env, timeoutMs: 10_000 });
+    worker = remoteWorker ? await remoteWorker.start(server.port, registrationFile, credentialFile) : spawn(process.execPath, [cli, "--root", workerRoot, "worker", "run", "--server", baseUrl, "--registration", registrationFile,
+        "--credential-file", credentialFile, "--harbor", harbor, "--docker", "/usr/local/bin/docker", "--once", "--poll-interval", "100ms", "--heartbeat-interval", "1s"], { env, stdio: ["ignore", "pipe", "pipe"] });
+    worker.stdout.pipe(workerLog, { end: false });
+    worker.stderr.pipe(workerLog, { end: false });
+    workerDone = new Promise((resolve, reject) => { worker.once("error", reject); worker.once("exit", code => resolve(code)); });
+    void workerDone.catch(() => { });
+    const admin = await daemonClient(controllerRoot);
+    const submitted = await admin.request("/v1/evals", { method: "POST", body: JSON.stringify({
+            request: { dataset, harness_ref: harness, model: `training/${binding.bindingId}`, training_binding: binding,
+                max_concurrent: 1, attempts: 1, infrastructure_retries: 0, timeout_ms: 120_000, setup_timeout_ms: 120_000 },
+            execution: { provider: "remote-docker", max_parallelism: 1, resources: { default_trial: resource },
+                build: { mode: "backend" }, model_capture: { mode: "proxy", required: true } },
+        }) });
+    evalId = validateEvalId(String(submitted.eval_id));
+    console.log(JSON.stringify({ event: "eval-submitted", eval_id: evalId }));
+    const deadline = Date.now() + 5 * 60_000;
+    let current = {}, previous = "";
+    while (Date.now() < deadline) {
+        current = await admin.request(`/v1/evals/${evalId}`);
+        const phase = JSON.stringify(current.control);
+        if (phase !== previous) {
+            previous = phase;
+            console.log(JSON.stringify({ event: "eval-control", control: current.control }));
+        }
+        if (current.result)
+            break;
+        if (worker.exitCode !== null && worker.exitCode !== 0)
+            throw new Error(`worker exited before result (${worker.exitCode})`);
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    await atomicWriteJSON(path.join(root, "eval-inspection.json"), current);
+    assert.ok(current.result, "real Harbor candidate timed out");
+    const result = current.result;
+    assert.equal(result.status, "succeeded", JSON.stringify(result));
+    assert.equal(result.trials.length, 1);
+    assert.equal(result.trials[0].observation_status, "valid");
+    const taskReward = result.trials[0].reward;
+    assert.ok(taskReward === 0 || taskReward === 1, "the task verifier must return a valid binary reward");
+    const boundRun = result.trials[0].run_id;
+    const evidence = await runCommand(process.execPath, [cli, "--root", controllerRoot, "training", "evidence", boundRun, "--json"], { env, timeoutMs: 10_000 });
+    await writeFile(path.join(root, "training-evidence.json"), evidence.stdout);
+    const nativeEvidence = JSON.parse(evidence.stdout);
+    assert.equal(nativeEvidence.termination, "terminated");
+    assert.equal(nativeEvidence.training_external.policy_version, binding.expectedPolicyVersion);
+    const trajectoryPath = nativeEvidence.result.trajectory.path;
+    assert.ok(!path.isAbsolute(trajectoryPath) && !trajectoryPath.split("/").includes(".."));
+    const trajectory = await readFile(path.join(controllerRoot, "runs", boundRun, trajectoryPath), "utf8");
+    const events = trajectory.trim().split("\n").map(line => JSON.parse(line));
+    const toolCalls = events.filter(event => event.data?.provider_type === "tool.completed").length;
+    const responses = events.filter(event => event.data?.provider_type === "provider.response");
+    assert.ok(toolCalls >= 2 && responses.length >= 2, "two sequential tool calls and a subsequent model reply are required");
+    assert.ok(responses.every(event => /^receipt_[a-f0-9]{32}$/.test(event.data?.native?.receipt_id ?? "")));
+    const receiptIds = responses.map(event => event.data.native.receipt_id);
+    assert.equal(new Set(receiptIds).size, receiptIds.length);
+    await writeFile(path.join(output, "trajectory.jsonl"), trajectory);
+    await writeFile(path.join(output, "training-evidence.json"), evidence.stdout);
+    const verifier = await runCommand(process.execPath, [cli, "--root", controllerRoot, "verifier", "inspect", boundRun, "--json"], { env, timeoutMs: 10_000 });
+    await writeFile(path.join(output, "verifier.json"), verifier.stdout);
+    await atomicWriteJSON(path.join(output, "eval-inspection.json"), current);
+    const leases = await readExecutionLeases(path.join(controllerRoot, "evals", evalId));
+    assert.equal(leases.length, 1);
+    assert.equal(leases[0].state, "released");
+    assert.ok(leases[0].release_confirmation);
+    assert.equal(await Promise.race([workerDone, new Promise(resolve => setTimeout(() => resolve("timeout"), 10_000))]), 0);
+    await remoteWorker?.collect();
+    for (const directory of [path.join(controllerRoot, "runs"), path.join(controllerRoot, "evals"), workerRoot]) {
+        for (const file of await regularFiles(directory))
+            assert.equal((await readFile(file)).includes(Buffer.from(secret)), false, `model credential leaked into ${file}`);
+    }
+    Object.assign(summary, { status: "passed", task_reward: taskReward, task_succeeded: taskReward === 1,
+        eval_id: evalId, run_id: boundRun, model_calls: responses.length, tool_calls: toolCalls, receipt_ids: receiptIds, lease_id: leases[0].lease_id, private_model_credential_in_public_files: false });
+    passed = true;
+}
+catch (error) {
+    Object.assign(summary, { status: "failed", error: error instanceof Error ? error.message : String(error) });
+    throw error;
+}
+finally {
+    if (evalId && !passed) {
+        const admin = await daemonClient(controllerRoot).catch(() => undefined);
+        await admin?.request(`/v1/evals/${evalId}/cancel`, { method: "POST", body: "{}" }).catch(() => { });
+    }
+    try {
+        await remoteWorker?.stop();
+    }
+    catch (error) {
+        summary.remote_stop_error = error instanceof Error ? error.message : String(error);
+    }
+    if (worker && worker.exitCode === null)
+        worker.kill("SIGTERM");
+    if (workerDone)
+        await Promise.race([workerDone.catch(() => null), new Promise(resolve => setTimeout(resolve, 10_000))]);
+    if (worker && worker.exitCode === null) {
+        worker.kill("SIGKILL");
+        await workerDone?.catch(() => null);
+    }
+    workerLog.end();
+    await server.close();
+    const leases = evalId ? await readExecutionLeases(path.join(controllerRoot, "evals", evalId)).catch(() => []) : [];
+    const leaseIds = leases.map(lease => lease.lease_id);
+    const cleanup = await Promise.all([
+        reapOwnedDockerResources({ root: controllerRoot, leaseIds, env }),
+        remoteWorker ? remoteWorker.cleanup(leaseIds).catch(error => ({ issues: [String(error)], retained: [] }))
+            : reapOwnedDockerResources({ root: workerRoot, leaseIds, env }),
+    ]);
+    if (remoteWorker && !passed)
+        await remoteWorker.collect().catch(error => { summary.remote_collection_error = String(error); });
+    summary.cleanup_proven = !summary.remote_stop_error && cleanup.every(report => report.issues.length === 0 && report.retained.length === 0);
+    await atomicWriteJSON(path.join(root, "summary.json"), summary);
+    await atomicWriteJSON(path.join(output, "summary.json"), summary);
+    console.log(JSON.stringify(summary));
+}
+assert.equal(summary.cleanup_proven, true, "owned Docker resources were not all released");
+async function prepareInputs() {
+    const task = path.join(dataset, "one"), source = path.join(root, "training-source");
+    await mkdir(path.join(task, "environment"), { recursive: true });
+    await mkdir(path.join(task, "tests"));
+    await writeFile(path.join(task, "instruction.md"), taskInput.instruction);
+    await writeFile(path.join(task, "environment/Dockerfile"), `FROM ${inspected.Id}\n`);
+    await writeFile(path.join(task, "task.toml"), `schema_version="1.4"\n[agent]\ntimeout_sec=120\n[environment]\ndocker_image="${inspected.Id}"\ncpus=1\nmemory_mb=1024\n[verifier]\ntimeout_sec=30\n`);
+    await writeFile(path.join(task, "tests/test.sh"), '#!/bin/bash\nset -eu\nmkdir -p /logs/verifier\nif test -f /tmp/gear-canary.txt && test "$(cat /tmp/gear-canary.txt)" = first-toolsecond-tool; then\n  printf "1" > /logs/verifier/reward.txt\nelse\n  printf "0" > /logs/verifier/reward.txt\nfi\n', { mode: 0o755 });
+    await mkdir(path.join(source, "integrations/training-tool"), { recursive: true });
+    await writeFile(path.join(source, "integrations/training-tool/cli.js"), await readFile("integrations/training-tool/cli.js"), { mode: 0o755 });
+    await writeFile(path.join(source, "package.json"), '{"type":"module"}');
+    for (const args of [["init"], ["add", "."], ["-c", "user.name=Hitch Canary", "-c", "user.email=canary@hitch.invalid", "commit", "-m", "fixed training harness canary"]])
+        await runCommand("git", args, { cwd: source, timeoutMs: 10_000 });
+    const commit = (await runCommand("git", ["rev-parse", "HEAD"], { cwd: source, timeoutMs: 10_000 })).stdout.trim();
+    return `training-tool@git+${pathToFileURL(source).href}#${commit}`;
+}
+async function regularFiles(directory) {
+    const files = [];
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+        const file = path.join(directory, entry.name);
+        if (entry.isDirectory())
+            files.push(...await regularFiles(file));
+        else if (entry.isFile())
+            files.push(file);
+    }
+    return files;
+}
+//# sourceMappingURL=canary-native-training.js.map