dsh-eval-guard 0.6.1 → 0.7.1

package/lib/index.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { execFileSync, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
 //#region src/config.ts
 /**
 * Plugin configuration. The Settings page writes this document through the
@@ -27,7 +28,9 @@ const Config = z.object({
 	pipProxyUrl: z.string().default("").volatile(),
 	cifarProxyUrl: z.string().default("").volatile(),
 	cifarMirror: z.string().default("toronto").volatile(),
-	customCifarUrl: z.string().default("").volatile()
+	customCifarUrl: z.string().default("").volatile(),
+	parallelEval: z.boolean().default(false).volatile(),
+	taskId: z.string().default("").volatile()
 });
 /** Clamp and normalize a live configuration object. */
 function resolveConfig(value) {
@@ -47,7 +50,9 @@ function resolveConfig(value) {
 		pipProxyUrl: typeof value?.pipProxyUrl === "string" ? value.pipProxyUrl : "",
 		cifarProxyUrl: typeof value?.cifarProxyUrl === "string" ? value.cifarProxyUrl : "",
 		cifarMirror: typeof value?.cifarMirror === "string" && value.cifarMirror !== "" ? value.cifarMirror : "toronto",
-		customCifarUrl: typeof value?.customCifarUrl === "string" ? value.customCifarUrl : ""
+		customCifarUrl: typeof value?.customCifarUrl === "string" ? value.customCifarUrl : "",
+		parallelEval: value?.parallelEval === true,
+		taskId: typeof value?.taskId === "string" ? value.taskId : ""
 	};
 }
 //#endregion
@@ -86,6 +91,8 @@ const NEURAL_FP32_TASK = "neural-fp32";
 const NEURAL_FP32_TASK_LABEL = "Neural-FP32 · 运算与性能";
 const NEURAL_CIFAR_TASK = "neural-cifar";
 const NEURAL_CIFAR_TASK_LABEL = "Neural-CIFAR · 从零训练图像分类";
+const NEURAL_PENDULUM_TASK = "neural-pendulum";
+const NEURAL_PENDULUM_TASK_LABEL = "Neural-Pendulum · 从零训练三节摆控制器";
 /** Common pip indexes offered by the settings page. */
 const CIFAR_MIRRORS = [{
 	id: "toronto",
@@ -465,6 +472,15 @@ const SYSTEM_READ_DIRS = [
 	"/sys",
 	"/var/lib"
 ];
+/**
+* Individual read-only system files commonly needed by benign inspection tools
+* such as uptime/who. Keep this list narrow; do not expose /run as a directory.
+*/
+const SYSTEM_READ_FILES = [
+	"/run/utmp",
+	"/run/utmpx",
+	"/var/log/wtmp"
+];
 /** Python stdlib/venv directories that may live next to a workspace. */
 function pythonRuntimeDirs(workspace) {
 	const dirs = /* @__PURE__ */ new Set();
@@ -587,6 +603,10 @@ function writePolicy(workspace, rules) {
 		}
 	} catch {}
 	lines.push(line("read", "/proc"));
+	for (const file of SYSTEM_READ_FILES) {
+		lines.push(line("read", file));
+		for (const ancestor of ancestorsOf(file)) lines.push(line("exact", ancestor));
+	}
 	lines.push(line("exact", "/"));
 	for (const ancestor of ancestorsOf(workspace)) lines.push(line("exact", ancestor));
 	for (const ancestor of ancestorsOf(runtime.node)) lines.push(line("exact", ancestor));
@@ -641,12 +661,26 @@ function bwrapArgs(workspace, cwd, rules, runtime) {
 	const args = [
 		"--unshare-all",
 		"--die-with-parent",
-		"--new-session"
+		"--new-session",
+		"--as-pid-1"
 	];
 	for (const system of SYSTEM_READ_DIRS) try {
 		if (fs.statSync(system).isDirectory()) args.push("--ro-bind", system, system);
 	} catch {}
 	args.push("--proc", "/proc", "--dev", "/dev");
+	const systemFiles = SYSTEM_READ_FILES.filter((file) => {
+		try {
+			return fs.statSync(file).isFile();
+		} catch {
+			return false;
+		}
+	});
+	if (systemFiles.some((file) => file.startsWith("/run/"))) args.push("--dir", "/run");
+	if (systemFiles.some((file) => file.startsWith("/var/log/"))) {
+		args.push("--dir", "/var");
+		args.push("--dir", "/var/log");
+	}
+	for (const file of systemFiles) args.push("--ro-bind", file, file);
 	args.push("--bind", workspace, workspace);
 	const tmp = path.join(workspace, ".tmp");
 	ensureDir(tmp);
@@ -779,12 +813,15 @@ var Guard = class {
 	startedAt = /* @__PURE__ */ new Map();
 	runs = /* @__PURE__ */ new Map();
 	sessionRuns = /* @__PURE__ */ new Map();
-	pending = /* @__PURE__ */ new Map();
 	offsets = /* @__PURE__ */ new Map();
 	knownAgents = /* @__PURE__ */ new Set();
 	toolCache = [];
 	disposers = [];
 	task;
+	/** Optional hook invoked when any run binds to an agent. */
+	onRunAssociated;
+	/** Optional automatic task binding for every main conversation. */
+	onAutoRun;
 	/** @param ctx - host context; @param raw - live config; @param task - the one task pack. */
 	constructor(ctx, services, raw, task) {
 		this.ctx = ctx;
@@ -840,7 +877,9 @@ var Guard = class {
 			pipProxyUrl: read("pipProxyUrl"),
 			cifarProxyUrl: read("cifarProxyUrl"),
 			cifarMirror: read("cifarMirror"),
-			customCifarUrl: read("customCifarUrl")
+			customCifarUrl: read("customCifarUrl"),
+			parallelEval: read("parallelEval"),
+			taskId: read("taskId")
 		});
 	}
 	/** Apply a new configuration document. */
@@ -1014,11 +1053,9 @@ var Guard = class {
 		if (this.enabled) this.forceApproval(agent.session);
 		const cwd = agent.session.header?.meta?.cwd;
 		if (cwd !== void 0) {
-			const pending = this.pending.get(cwd);
-			if (pending !== void 0 && pending.expiresAt > Date.now()) {
-				this.pending.delete(cwd);
-				this.associate(pending.runId, agent);
-			}
+			if (this.enabled) try {
+				this.onAutoRun?.(agent, cwd);
+			} catch {}
 		}
 	}
 	/** An agent went away. */
@@ -1036,7 +1073,12 @@ var Guard = class {
 			}
 		}
 	}
-	/** Associate one pending run with the new session. */
+	/** Bind an already-registered run to an agent. */
+	attachRun(agent, run) {
+		this.runs.set(run.runId, run);
+		this.associate(run.runId, agent);
+	}
+	/** Associate one run with the new session. */
 	associate(runId, agent) {
 		const run = this.runs.get(runId);
 		if (run === void 0) return;
@@ -1049,6 +1091,9 @@ var Guard = class {
 		this.sessionRuns.set(agent.id, runId);
 		this.writeRun(run);
 		this.writeUsage(runId, this.zeroUsage(run.startedAt));
+		try {
+			this.onRunAssociated?.(agent, run);
+		} catch {}
 	}
 	/** Session event intake. */
 	onSessionEvent(session, event) {
@@ -1283,10 +1328,9 @@ var Guard = class {
 			} catch {}
 		}
 	}
-	/** Remove old sandbox policy files and expired pending associations. */
+	/** Remove old sandbox policy files. */
 	cleanupTemp() {
 		const now = Date.now();
-		for (const [workspace, pending] of [...this.pending]) if (pending.expiresAt <= now) this.pending.delete(workspace);
 		const tmp = path.join(guardRoot(), "tmp");
 		try {
 			for (const entry of fs.readdirSync(tmp)) {
@@ -1367,10 +1411,12 @@ var Guard = class {
 		this.writeRun(run);
 		this.writeUsage(run.runId, this.zeroUsage(null));
 		fs.writeFileSync(path.join(guardRoot(), "runs", run.runId, "violations.jsonl"), "", "utf8");
-		this.pending.set(run.workspacePath, {
-			runId: run.runId,
-			expiresAt: Date.now() + 216e5
-		});
+	}
+	/** Resolve the registered run bound to one agent session. */
+	runForSession(sessionId) {
+		if (sessionId === void 0) return void 0;
+		const runId = this.sessionRuns.get(sessionId);
+		return runId === void 0 ? void 0 : this.runs.get(runId);
 	}
 	/** Build the prompt for one task with only installed tools listed. */
 	promptFor(workspacePath, source, task = this.task) {
@@ -1752,6 +1798,14 @@ const TASKS = [
 		timeLimitMinutes: 1440,
 		timeLimitEnabled: false,
 		needsSetup: true
+	},
+	{
+		id: NEURAL_PENDULUM_TASK,
+		label: NEURAL_PENDULUM_TASK_LABEL,
+		description: "从零实现纯 C++17 神经网络基础设施，用三个关节角度控制预编译三节摆起摆并稳定保持；评测固定初始状态，统计 t_can。",
+		timeLimitMinutes: 1440,
+		timeLimitEnabled: false,
+		needsSetup: true
 	}
 ];
 /** The tank task definition (original prompt; only halftime mechanics removed). */
@@ -2056,6 +2110,34 @@ const NEURAL_CIFAR_DEFINITION = {
 		].join("\n");
 	}
 };
+/** Neural-Pendulum swing-up task. */
+const NEURAL_PENDULUM_DEFINITION = {
+	id: NEURAL_PENDULUM_TASK,
+	label: NEURAL_PENDULUM_TASK_LABEL,
+	description: TASKS[11].description,
+	asset: path.join(packageRoot(), "assets", "neural-pendulum", "workspace.zip"),
+	timeLimitMinutes: 1440,
+	timeLimitEnabled: false,
+	needsSetup: true,
+	prompt() {
+		return [
+			"你是一名控制与神经网络工程师。任务：从零实现纯 C++17、仅 CPU、fp32 的神经网络基础设施，并用它训练一个控制器，控制预编译的三节摆从接近全向下起摆，使三根杆全部进入竖直向上容差并尽可能长时间保持。",
+			"",
+			"请先完整阅读 TASK.md；它是权威规则。硬约束：仅 C++17 标准库、仅 CPU、fp32；不使用 Python/OpenCL/CUDA/BLAS/Eigen/第三方库；必须从提交源码构建出 build/control 与 build/libnn.a；基础设施需实现工作区公开头文件 include/nn/nn.hpp 的契约，隐藏测试由评测侧独立编译链接。",
+			"",
+			"环境细节：joint1 与 joint3 驱动，joint2 被动；控制频率 100 Hz；每回合最多 3000 步（30 s），达到上限后继续 step 返回 {\"error\":\"episode_finished\"}，必须 reset。环境只返回三个关节角度（弧度，不除 pi），不返回 reward/loss/cost/done；环境不提供杆长、质量、惯量、角速度或 tip。训练 reset 带小范围随机初始角度和角速度；评测使用固定初始状态，无随机扰动。",
+			"",
+			"优化目标：从接近全向下起摆，使三根杆全部进入 0.05 rad 的竖直向上容差，并尽可能长时间保持；评测指标为 t_can。损失函数、奖励、优化器、网络结构和训练方法由你自行设计，不规定任何训练方案。",
+			"",
+			"评测会从干净副本重新构建提交源码，编译并运行宿主侧隐藏基础设施测试，然后在固定初始状态上驱动 build/control，统计连续全向上保持时间 t_can。不要把任何未提交的二进制、临时构建产物或外部进程当作交付依赖。",
+			"使用宿主工具 eval_submit 提交当前源码快照，使用 eval_test 请求宿主评测最新提交。提交快照、事件、测试结果和最终分数全部保存在工作区之外的宿主目录；不要尝试读取或修改这些数据，也不要依赖任何工作区内的测试结果文件。最终评测使用最新提交快照，按宿主事件时间积分计算分数。",
+			"",
+			"工作方式：先完成最小可构建的基础设施和 control 协议；再持续做控制/训练实验并记录可复现结果；最终保证工作区从零构建、隐藏基础设施测试通过、control 可被评测驱动，并留下 NOTES.md/RESULTS.md。",
+			"",
+			"不要向我提问，也不要等待确认，独立完成。"
+		].join("\n");
+	}
+};
 /** All task definitions keyed by id. */
 const TASK_DEFINITIONS = {
 	[TANK_TASK]: TANK_DEFINITION,
@@ -2068,7 +2150,8 @@ const TASK_DEFINITIONS = {
 	[FEATUREBENCH_TASK]: FEATUREBENCH_DEFINITION,
 	[NEURAL_CPP_TASK]: NEURAL_CPP_DEFINITION,
 	[NEURAL_FP32_TASK]: NEURAL_FP32_DEFINITION,
-	[NEURAL_CIFAR_TASK]: NEURAL_CIFAR_DEFINITION
+	[NEURAL_CIFAR_TASK]: NEURAL_CIFAR_DEFINITION,
+	[NEURAL_PENDULUM_TASK]: NEURAL_PENDULUM_DEFINITION
 };
 var TaskService = class {
 	guard;
@@ -2079,6 +2162,272 @@ var TaskService = class {
 		this.registry = registry;
 		this.jobs = new JobManager();
 	}
+	/** Host-side directory for one workspace's authoritative task state. */
+	hostDir(workspaceId) {
+		return path.join(guardRoot(), "neural-pendulum", workspaceId.replace(/[^A-Za-z0-9_.-]/g, "_"));
+	}
+	hostEvents(workspaceId) {
+		return path.join(this.hostDir(workspaceId), "events.jsonl");
+	}
+	appendHostEvent(workspaceId, event) {
+		const dir = this.hostDir(workspaceId);
+		fs.mkdirSync(dir, { recursive: true });
+		fs.appendFileSync(this.hostEvents(workspaceId), JSON.stringify(event) + "\n", "utf8");
+	}
+	hostLatestSubmission(workspaceId) {
+		const root = path.join(this.hostDir(workspaceId), "submissions");
+		if (!fs.existsSync(root)) return void 0;
+		const dirs = fs.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+		if (dirs.length === 0) return void 0;
+		const id = dirs.map((entry) => entry.name).sort((a, b) => {
+			const am = fs.statSync(path.join(root, a)).mtimeMs;
+			return fs.statSync(path.join(root, b)).mtimeMs - am;
+		})[0];
+		return {
+			id,
+			path: path.join(root, id)
+		};
+	}
+	copySnapshot(source, destination) {
+		const excluded = /* @__PURE__ */ new Set([
+			"build",
+			".git",
+			".eval",
+			".submissions",
+			"node_modules",
+			"__pycache__",
+			".venv"
+		]);
+		let count = 0;
+		const walk = (dir) => {
+			for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+				if (excluded.has(entry.name)) continue;
+				const from = path.join(dir, entry.name);
+				const to = path.join(destination, path.relative(source, from));
+				if (entry.isDirectory()) {
+					fs.mkdirSync(to, { recursive: true });
+					walk(from);
+				} else if (entry.isFile()) {
+					fs.mkdirSync(path.dirname(to), { recursive: true });
+					fs.copyFileSync(from, to);
+					count++;
+				}
+			}
+		};
+		fs.mkdirSync(destination, { recursive: true });
+		walk(source);
+		return count;
+	}
+	/** Host-side submit: snapshot the workspace into the run directory. */
+	hostSubmit(run) {
+		const done = path.join(this.hostDir(run.workspaceId), "done");
+		if (fs.existsSync(done)) return {
+			ok: false,
+			error: "task already completed"
+		};
+		const id = Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 8);
+		const metaPath = path.join(this.hostDir(run.workspaceId), "meta.json");
+		if (!fs.existsSync(metaPath)) {
+			fs.mkdirSync(this.hostDir(run.workspaceId), { recursive: true });
+			fs.writeFileSync(metaPath, JSON.stringify({
+				started_at: run.createdAt / 1e3,
+				t_tgt: 10
+			}), "utf8");
+		}
+		const destination = path.join(this.hostDir(run.workspaceId), "submissions", id);
+		if (fs.existsSync(destination)) return {
+			ok: false,
+			error: "submission id collision"
+		};
+		const files = this.copySnapshot(run.workspacePath, destination);
+		const hash = createHash("sha256");
+		const hashDir = (dir) => {
+			for (const entry of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+				const full = path.join(dir, entry.name);
+				if (entry.isDirectory()) hashDir(full);
+				else if (entry.isFile()) {
+					hash.update(path.relative(destination, full));
+					hash.update(fs.readFileSync(full));
+				}
+			}
+		};
+		hashDir(destination);
+		this.appendHostEvent(run.workspaceId, {
+			event: "submit",
+			time: Date.now() / 1e3,
+			submission_id: id,
+			source_hash: "sha256:" + hash.digest("hex"),
+			files
+		});
+		return {
+			ok: true,
+			submission: id,
+			files
+		};
+	}
+	async runHostEval(workspaceId) {
+		const latest = this.hostLatestSubmission(workspaceId);
+		if (latest === void 0) return {
+			stage: "no_submission",
+			t_can: 0,
+			completed: false,
+			error: ""
+		};
+		const temp = fs.mkdtempSync(path.join(guardRoot(), "pend-eval-"));
+		try {
+			const submissions = path.join(temp, ".eval", "submissions");
+			fs.mkdirSync(submissions, { recursive: true });
+			fs.cpSync(latest.path, path.join(submissions, latest.id), { recursive: true });
+			const events = this.hostEvents(workspaceId);
+			fs.writeFileSync(path.join(temp, ".eval", "events.jsonl"), fs.existsSync(events) ? fs.readFileSync(events) : "", "utf8");
+			fs.writeFileSync(path.join(temp, ".eval", "meta.json"), JSON.stringify({
+				started_at: Date.now() / 1e3,
+				t_tgt: 10
+			}), "utf8");
+			const resultFile = path.join(temp, "result.json");
+			const script = path.join(packageRoot(), "neural-pendulum-eval", "run_eval.py");
+			const env = {
+				...process.env,
+				EVAL_RESULT_FILE: resultFile,
+				PYTHONPATH: "",
+				PYTHONHOME: ""
+			};
+			const child = spawn("python3", [
+				"-X",
+				"utf8",
+				script,
+				"--workspace",
+				temp
+			], { env });
+			let stderr = "";
+			child.stderr?.on("data", (chunk) => {
+				stderr += String(chunk);
+			});
+			await new Promise((resolve, reject) => {
+				child.on("error", reject);
+				child.on("close", () => resolve());
+			});
+			if (!fs.existsSync(resultFile)) return {
+				stage: "controller",
+				t_can: 0,
+				completed: false,
+				error: stderr || "evaluator failed"
+			};
+			const value = JSON.parse(fs.readFileSync(resultFile, "utf8"));
+			const error = String(value.error ?? "");
+			let stage = "controller";
+			if (error.includes("cmake") || error.includes("build")) stage = "compile";
+			else if (error.includes("selftest") || value.infra_ok === false) stage = "infra";
+			else if (error.includes("controller")) stage = "controller";
+			else if (value.success === true) stage = "completed";
+			else if (value.infra_ok === true) stage = "scoring";
+			else stage = "simulation";
+			return {
+				stage,
+				t_can: Number(value.t_can ?? 0),
+				completed: value.success === true,
+				error
+			};
+		} finally {
+			fs.rmSync(temp, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	/** Host-side test: evaluate the latest host submission and write the event. */
+	async hostTest(run) {
+		const done = path.join(this.hostDir(run.workspaceId), "done");
+		if (fs.existsSync(done)) return {
+			ok: false,
+			stage: "completed",
+			error: "task already completed"
+		};
+		const latest = this.hostLatestSubmission(run.workspaceId);
+		if (latest === void 0) {
+			this.appendHostEvent(run.workspaceId, {
+				event: "test",
+				time: Date.now() / 1e3,
+				submission_id: "",
+				stage: "no_submission",
+				t_can: 0,
+				completed: false,
+				error: ""
+			});
+			return {
+				ok: true,
+				stage: "no_submission",
+				t_can: 0,
+				completed: false,
+				error: ""
+			};
+		}
+		const value = await this.runHostEval(run.workspaceId);
+		const stage = String(value.stage ?? "simulation");
+		const tCan = Number(value.t_can ?? 0);
+		const completed = stage === "completed" && Number.isFinite(tCan);
+		this.appendHostEvent(run.workspaceId, {
+			event: "test",
+			time: Date.now() / 1e3,
+			submission_id: latest.id,
+			stage,
+			t_can: tCan,
+			completed,
+			error: String(value.error ?? "")
+		});
+		if (completed) fs.writeFileSync(done, String(Date.now() / 1e3), "utf8");
+		return {
+			ok: true,
+			stage,
+			t_can: tCan,
+			completed,
+			error: String(value.error ?? "")
+		};
+	}
+	/** Build a temporary workspace containing the host-side authoritative state. */
+	stageHostWorkspace(workspaceId) {
+		if (this.hostLatestSubmission(workspaceId) === void 0) return void 0;
+		const temp = fs.mkdtempSync(path.join(guardRoot(), "pend-eval-view-"));
+		const state = path.join(temp, ".eval");
+		fs.mkdirSync(path.join(state, "submissions"), { recursive: true });
+		const root = path.join(this.hostDir(workspaceId), "submissions");
+		for (const entry of fs.readdirSync(root, { withFileTypes: true })) if (entry.isDirectory()) fs.cpSync(path.join(root, entry.name), path.join(state, "submissions", entry.name), { recursive: true });
+		const events = this.hostEvents(workspaceId);
+		fs.writeFileSync(path.join(state, "events.jsonl"), fs.existsSync(events) ? fs.readFileSync(events) : "", "utf8");
+		const meta = path.join(this.hostDir(workspaceId), "meta.json");
+		fs.writeFileSync(path.join(state, "meta.json"), fs.existsSync(meta) ? fs.readFileSync(meta) : JSON.stringify({
+			started_at: Date.now() / 1e3,
+			t_tgt: 10
+		}), "utf8");
+		return temp;
+	}
+	/** Bind every main conversation to the configured active task, no install needed. */
+	autoBind(agent, cwd) {
+		if (!this.guard.active) return false;
+		const taskId = this.guard.configuration.taskId;
+		if (taskId === "") return false;
+		const definition = TASK_DEFINITIONS[taskId];
+		if (definition === void 0) return false;
+		const workspaceId = (this.registry.list?.() ?? []).find((workspace) => path.resolve(workspace.path) === path.resolve(cwd))?.id ?? "path-" + createHash("sha1").update(cwd).digest("hex").slice(0, 16);
+		const runId = this.newRunId();
+		const prompt = this.promptNotice(this.guard.promptFor(cwd, this.materialZip(taskId), definition));
+		const run = {
+			runId,
+			task: definition.id,
+			workspaceId,
+			workspacePath: cwd,
+			sessionId: null,
+			createdAt: Date.now(),
+			startedAt: null,
+			endedAt: null,
+			status: "prepared",
+			prompt,
+			timeLimitMinutes: this.guard.configuration.timeLimitMinutes
+		};
+		this.guard.registerRun(run);
+		this.guard.attachRun(agent, run);
+		return true;
+	}
 	/** The clone URL for a task, honouring the selected source. */
 	cloneUrl(definition, options) {
 		const repo = definition.repoUrl ?? "";
@@ -2268,26 +2617,7 @@ var TaskService = class {
 			onFailure: cleanupInstall,
 			onSuccess: () => {
 				if (definition.needsSetup) this.cleanupWorkspace(checked.path);
-				const runId = this.newRunId();
-				const prompt = this.guard.promptFor(checked.path, this.materialZip(taskId), definition);
-				const run = {
-					runId,
-					task: definition.id,
-					workspaceId,
-					workspacePath: checked.path,
-					sessionId: null,
-					createdAt: Date.now(),
-					startedAt: null,
-					endedAt: null,
-					status: "prepared",
-					prompt,
-					timeLimitMinutes: this.guard.configuration.timeLimitMinutes
-				};
-				this.guard.registerRun(run);
-				return {
-					runId,
-					prompt
-				};
+				return { prompt: this.promptNotice(this.guard.promptFor(checked.path, this.materialZip(taskId), definition)) };
 			}
 		});
 		if (job.status === "failed") cleanupInstall();
@@ -2307,11 +2637,16 @@ var TaskService = class {
 			ok: false,
 			error: checked.error
 		};
+		if (!this.guard.active) return {
+			ok: false,
+			error: "请先启用评测守护。"
+		};
 		const script = path.join(packageRoot(), "eval", taskId + ".py");
 		if (!fs.existsSync(script)) return {
 			ok: false,
 			error: "评测脚本不存在：" + script
 		};
+		const evalWorkspace = (taskId === "neural-pendulum" ? this.stageHostWorkspace(workspaceId) : void 0) ?? checked.path;
 		return {
 			ok: true,
 			jobId: this.jobs.start({
@@ -2324,18 +2659,24 @@ var TaskService = class {
 					"utf8",
 					script,
 					"--workspace",
-					checked.path
+					evalWorkspace
 				],
 				cwd: packageRoot(),
 				env: {
 					PYTHONPATH: "",
 					PYTHONHOME: "",
 					EVAL_CIFAR_PROXY: this.proxyValue(this.guard.configuration.cifarProxyUrl),
-					EVAL_CIFAR_URL: this.cifarUrl(this.guard.configuration)
+					EVAL_CIFAR_URL: this.cifarUrl(this.guard.configuration),
+					EVAL_SUBMISSIONS_ROOT: path.join(guardRoot(), "submissions", workspaceId.replace(/[^A-Za-z0-9_.-]/g, "_"))
 				}
 			}).id
 		};
 	}
+	/** Add the optional shared-machine notice to a task prompt. */
+	promptNotice(prompt) {
+		if (!this.guard.configuration.parallelEval) return prompt;
+		return prompt + "\n\n注意：当前机器可能同时运行其他 agent 的评测/训练任务。运行环境的 CPU、内存、IO 与可用并发会因其他 agent 的行为而波动；请自行适应这种波动，不要假设环境稳定，也不要依赖固定墙钟时间或固定可用资源来判断进度。";
+	}
 	/** Copy the packaged workspace.zip to a stable material path for install/manual use. */
 	materialZip(taskId = TANK_TASK) {
 		const definition = TASK_DEFINITIONS[taskId];
@@ -2394,25 +2735,9 @@ var TaskService = class {
 				error: "任务准备失败：" + (error instanceof Error ? error.message : String(error))
 			};
 		}
-		const runId = this.newRunId();
-		const prompt = promptOverride ?? this.guard.promptFor(checked.path, this.materialZip(taskId), definition);
-		const run = {
-			runId,
-			task: definition.id,
-			workspaceId,
-			workspacePath: checked.path,
-			sessionId: null,
-			createdAt: Date.now(),
-			startedAt: null,
-			endedAt: null,
-			status: "prepared",
-			prompt,
-			timeLimitMinutes: this.guard.configuration.timeLimitMinutes
-		};
-		this.guard.registerRun(run);
+		const prompt = this.promptNotice(promptOverride ?? this.guard.promptFor(checked.path, this.materialZip(taskId), definition));
 		return {
 			ok: true,
-			runId,
 			workspaceId,
 			workspacePath: checked.path,
 			prompt
@@ -2423,7 +2748,7 @@ var TaskService = class {
 		const definition = TASK_DEFINITIONS[taskId];
 		if (definition === void 0) return "";
 		const workspace = this.registry.get(workspaceId);
-		return this.guard.promptFor(workspace?.path ?? "", this.materialZip(taskId), definition);
+		return this.promptNotice(this.guard.promptFor(workspace?.path ?? "", this.materialZip(taskId), definition));
 	}
 	/** Filesystem paths for the manual channel. */
 	manualPaths(workspaceId, taskId = TANK_TASK) {
@@ -2435,7 +2760,7 @@ var TaskService = class {
 		const workspace = this.registry.get(workspaceId);
 		return {
 			source: this.materialZip(taskId),
-			prompt: this.guard.promptFor(workspace?.path ?? "", this.materialZip(taskId), definition)
+			prompt: this.promptNotice(this.guard.promptFor(workspace?.path ?? "", this.materialZip(taskId), definition))
 		};
 	}
 	/** A unique run id. */
@@ -2657,6 +2982,70 @@ function registerRoutes(ctx, guard, tasks) {
 	});
 }
 //#endregion
+//#region src/submission-tools.ts
+const OUTPUT_SCHEMA = {
+	type: "object",
+	additionalProperties: true,
+	properties: {
+		ok: { type: "boolean" },
+		submission: { type: "string" },
+		files: { type: "number" },
+		stage: { type: "string" },
+		t_can: { type: "number" },
+		completed: { type: "boolean" },
+		error: { type: "string" }
+	},
+	required: ["ok"]
+};
+function render(_args, value) {
+	return [{
+		type: "text",
+		text: JSON.stringify(value)
+	}];
+}
+function resolve(guard, exec) {
+	if (!guard.active) throw new Error("eval guard is disabled");
+	const run = guard.runForSession(exec.agent?.id);
+	if (run === void 0) throw new Error("eval task run is not active for this session");
+	if (run.task !== "neural-pendulum") throw new Error("this tool is only available for the neural-pendulum task");
+	return run;
+}
+/** Install the task tools into one agent's own scoped registry. */
+function registerAgentSubmissionTools(agent, guard, tasks) {
+	const tools = agent.ctx?.tools;
+	if (tools === void 0) return;
+	const submit = {
+		name: "eval_submit",
+		description: "Submit the current workspace source as a new immutable snapshot for the active Neural-Pendulum run. Submission itself does not change the score.",
+		parameters: {
+			type: "object",
+			properties: {}
+		},
+		output: {
+			schema: OUTPUT_SCHEMA,
+			render
+		},
+		timeoutMs: 6e4,
+		execute: async (_args, exec) => tasks.hostSubmit(resolve(guard, exec))
+	};
+	const test = {
+		name: "eval_test",
+		description: "Run a host-side evaluation of the latest submitted snapshot and return stage, t_can, completed and error. Only successful tests update the score.",
+		parameters: {
+			type: "object",
+			properties: {}
+		},
+		output: {
+			schema: OUTPUT_SCHEMA,
+			render
+		},
+		timeoutMs: 9e5,
+		execute: async (_args, exec) => tasks.hostTest(resolve(guard, exec))
+	};
+	tools.register(submit);
+	tools.register(test);
+}
+//#endregion
 //#region src/index.ts
 /** Stable Cordis plugin name. */
 const name = "eval-guard";
@@ -2701,7 +3090,12 @@ function apply(ctx, config) {
 			on: (event, listener) => child.on(event, listener)
 		};
 		const guard = new Guard(ctx, services, config, TANK_DEFINITION);
-		registerRoutes(ctx, guard, new TaskService(guard, services.workspaceRegistry));
+		const tasks = new TaskService(guard, services.workspaceRegistry);
+		guard.onRunAssociated = (agent, run) => {
+			registerAgentSubmissionTools(agent, guard, tasks);
+		};
+		guard.onAutoRun = (agent, cwd) => tasks.autoBind(agent, cwd);
+		registerRoutes(ctx, guard, tasks);
 		child.inject(["settings"], (settingsCtx) => {
 			const settings = settingsCtx.get("settings");
 			settingsCtx.effect(() => settings.configure({ auto: false }, ctx.fiber), "eval-guard: settings page");