From 159d7112aeae2262777f7243f734f2d3653533d8 Mon Sep 17 00:00:00 2001 From: host Date: Wed, 4 Nov 2026 16:51:03 +0000 Subject: [PATCH] Audit N-12: goal pushback preamble reaches breakpoint resume via --resume-note Goal tasks pushed back by the audit loop lost the packet preamble on the next round: claim-time _apply_audit_loop_packet pasted it into the in-memory prompt/goal, but the next round collided with the existing host task name, fell back to breakpoint goal-resume (no --goal-text), and the host reused the stored goal, discarding the preamble. Fix (minimal, direction (c) trimmed): host goal-resume gains --resume-note, accepted only by the breakpoint branch and prepended to the first turn prompt of this resume only -- never written back to the stored goal, never touching rounds or verification. The worker stashes the same preamble as the memory-only _audit_loop_resume_note at claim time and forwards it on breakpoint resume (Local/Docker goal_resume_task and the popen goal-resume command, each guarded to ignore the note when goal_text is set for a new-goal resume). Accounting untouched: audit 3-round cap, goal_max_rounds/quota, and DB goal columns are unchanged; non-goal pushback is unchanged. Tests: cloud/tests/test_audit_n12.py (9 tests) -- host first-turn-only note + stored-goal/rounds, worker exists-fallback end-to-end with --resume-note, non-goal regression, goal-column accounting, and Local/Docker/popen command shapes. Full cloud suite: 1760 OK (skipped=11), baseline 1751 + 9 new; tests/test_host.py: 62 OK. --- cloud/sandbox.py | 21 +- cloud/tests/test_audit_n12.py | 355 ++++++++++++++++++++++++++++++++++ cloud/worker.py | 31 ++- host.py | 25 ++- 4 files changed, 421 insertions(+), 11 deletions(-) create mode 100644 cloud/tests/test_audit_n12.py diff --git a/cloud/sandbox.py b/cloud/sandbox.py index caffc90..5e79367 100644 --- a/cloud/sandbox.py +++ b/cloud/sandbox.py @@ -687,7 +687,8 @@ class LocalExecutor(Executor): task["id"], self.runner(cmd)) def goal_resume_task(self, task, goal_text=None, extra_env=None, - model_provider=None, max_rounds=None) -> dict: + model_provider=None, max_rounds=None, + resume_note=None) -> dict: """调 host.py goal-resume，分两种调用（P1，与 worker、 host 三处一致，绝不能混用）： - 断点续跑：goal_text=None（worker 的 _resume_kind= @@ -699,6 +700,10 @@ class LocalExecutor(Executor): - 开新目标：goal_text 为新目标文本（云端 /continue 带 goal_mode=1 时走这里）。命令带 --goal-text 与 --max-rounds（默认 0，新语义不限轮次，上界是配额）。 + resume_note（N-12）：仅断点续跑时用，作 --resume-note + 传给 host，host 只贴进本次续跑第一轮的 prompt，不写回 + 存储的 goal、不改轮次与验收；goal_text 非空（开新目标） + 时忽略它（新目标自带 goal_text，不需要断点备注）。 不传 --repo：goal-resume 操作已有 host 任务，不新建 worktree。结论解析与 goal_task 同款。 """ @@ -715,6 +720,8 @@ class LocalExecutor(Executor): str(max_rounds if max_rounds is not None else 0)] elif max_rounds is not None: cmd += ["--max-rounds", str(max_rounds)] + if goal_text is None and resume_note: + cmd += ["--resume-note", resume_note] return self._goal_result_from_runner( task["id"], self._run_local(cmd, extra_env)) @@ -863,10 +870,15 @@ class LocalExecutor(Executor): # 沿用原 goal+verify 断点续跑，绝不能用续跑消息覆盖 # 原 verify）；其它情况（开新目标）才用 task["prompt"] #（worker 已换成续跑消息）当 --goal-text，--max-rounds 0。 + # N-12：断点续跑且任务带审计推回备注时，另传 + # --resume-note（只贴第一轮 prompt，不写回存储的 goal）。 cmd += ["goal-resume", "--task", self._host_name(task)] if task.get("_resume_kind") != "breakpoint": cmd += ["--goal-text", task["prompt"], "--max-rounds", "0"] + elif task.get("_audit_loop_resume_note"): + cmd += ["--resume-note", + task["_audit_loop_resume_note"]] else: cmd += ["dispatch", "--name", self._host_name(task), "--task", task["prompt"]] @@ -1634,11 +1646,14 @@ class DockerExecutor(Executor): def goal_resume_task(self, task, goal_text=None, timeout=None, extra_mounts=None, network=None, extra_env=None, model_provider=None, - max_rounds=None) -> dict: + max_rounds=None, resume_note=None) -> dict: """容器内调 host.py goal-resume，分两种调用（P1，与 Local goal_resume_task 同款契约）：断点续跑传 goal_text=None （不带 --goal-text，host 沿用原 goal+verify+轮次），开新 目标才传 goal_text（带 --goal-text 与 --max-rounds，默认 0）。 + resume_note（N-12）：仅断点续跑时作 --resume-note 传给 + host（Local 同款语义：只贴第一轮 prompt，不写回存储的 + goal）；goal_text 非空时忽略它。 解析与 goal_task 同款（完整 stdout 结论、存库截尾），但 没有“已存在”分支：goal-resume 本来就是操作已有 host 任务， 不存在 dispatch 撞名问题；returncode 非 0 时：有结论仍 @@ -1654,6 +1669,8 @@ class DockerExecutor(Executor): if max_rounds is not None else 0)] elif max_rounds is not None: _resume_args += ["--max-rounds", str(max_rounds)] + if goal_text is None and resume_note: + _resume_args += ["--resume-note", resume_note] inner = self._inner_host_command( *_resume_args, model=task.get("model"), effort=task.get("effort"), diff --git a/cloud/tests/test_audit_n12.py b/cloud/tests/test_audit_n12.py new file mode 100644 index 0000000..a0ebcd4 --- /dev/null +++ b/cloud/tests/test_audit_n12.py @@ -0,0 +1,355 @@ +"""N-12：goal 任务审计推回包前言在断点续跑时丢失的修复测试。 + +缺口链路（批 5 定性）：认领时 _apply_audit_loop_packet 把包 +前言贴进内存 prompt 与 goal，但推回后的 goal 任务下一轮无 +_resume、无断点标记，先走 goal_task 撞宿主任务名已存在，再 +经已存在回落走断点续跑（goal-resume 不传 --goal-text，宿主 +沿用存储的原 goal），内存 goal 里的前言被覆盖、前言丢失。 + +修复（c 精简版）：新增 host 侧 --resume-note 参数，只由断 +点分支受理，只贴进本次续跑第一轮的 prompt，绝不写回存储 +的 goal、不改轮次与验收；worker 认领贴前言时另存内存键 +_audit_loop_resume_note，断点续跑时作 --resume-note 透传 +（Local/Docker 的 goal_resume_task 与 popen 的 goal-resume +命令构造各有配对守卫：goal_text 已设时忽略备注）。 + +只用注入的假 runner / 假 server，不跑真实模型回合、不联 +网、不登录任何服务。断言口径：包前言渲染的是 findings +（id/证据/复现/验收）与固定收尾句，criteria 是包里的门映 +射（由接线会计用，不渲染进前言文本），所以“前言到达” +断言为前言文本含 finding id 与证据/验收句；criteria 仍在 +包 JSON 里可读、接线会计不变。 +""" + +import json +import os +import sqlite3 +import sys +import tempfile +import time +import unittest +from pathlib import Path +from types import SimpleNamespace +from unittest import mock + +try: + from cloud.sandbox import DockerExecutor, LocalExecutor + from cloud.server import init_db + from cloud.worker import Worker +except ImportError: # discover -s cloud/tests 时把项目根目录补进 sys.path + sys.path.insert(0, str(Path(__file__).resolve().parents[2])) + from cloud.sandbox import DockerExecutor, LocalExecutor + from cloud.server import init_db + from cloud.worker import Worker + + +def _host_mod(): + """host.py 只在测试执行时才导入，不在模块层导入：host.py + 有 `import queue`（标准库），模块层导入会先于 + test_queue_sandbox 的模块导入把标准库 queue 写进 + sys.modules，导致后者 `from queue import TaskQueue` + （本意是 cloud/queue.py）拿到标准库而导入失败、47 项 + 用例缺席。全部模块发现完成后再导入 host 就不受影响 + （test_queue_sandbox 的名字在发现时已绑定 cloud/queue）。""" + try: + import host as host_mod + except ImportError: + sys.path.insert(0, str(Path(__file__).resolve().parents[2])) + import host as host_mod + return host_mod + + +def _packet(task_id="TG", round_no=1): + return json.dumps({ + "task_id": task_id, "round": round_no, + "findings": [{"id": "execution_failed", "severity": "high", + "evidence": "boom detail", "reproduction": "re-run", + "acceptance": "task completes", + "kind": "deterministic", "gate": "execution"}], + "criteria": {"execution_failed": "execution"}}) + + +def _insert_task(db_path, task_id, prompt="do work", status="queued", + project_id="p1", audit_loop=0, packet=None, + goal_mode=0, goal=None, verify_command=None, + goal_max_rounds=None): + now = time.time() + conn = sqlite3.connect(db_path) + try: + conn.execute( + "INSERT INTO tasks(id, project_id, prompt, status," + " idempotency_key, depends_on, priority, created_by," + " created_at, updated_at, last_heartbeat, audit_loop," + " audit_loop_packet, goal_mode, goal, verify_command," + " goal_max_rounds)" + " VALUES(?, ?, ?, ?, NULL, '[]', 0, 'tester', ?, ?, NULL," + " ?, ?, ?, ?, ?, ?)", + (task_id, project_id, prompt, status, now, now, + audit_loop, packet, goal_mode, goal, verify_command, + goal_max_rounds), + ) + conn.commit() + finally: + conn.close() + + +def _row(db_path, task_id): + conn = sqlite3.connect(db_path) + try: + return conn.execute( + "SELECT status, prompt, goal, verify_command," + " goal_max_rounds, audit_loop_packet" + " FROM tasks WHERE id = ?", (task_id,)).fetchone() + finally: + conn.close() + + +class _FakeServer: + """只记 prompt、不跑模型：run_turn 返回 completed。""" + + def __init__(self): + self.prompts = [] + + def run_turn(self, thread_id, prompt, **kwargs): + self.prompts.append(prompt) + return {"status": "completed", "text": "did work", "usage": {}} + + +def _host_state(tmp, task): + state_path = os.path.join(tmp, "host-state.json") + state = {"tasks": {task["name"]: task}, "automations": [], + "usage": {}} + return state, state_path + + +class HostResumeNoteTests(unittest.TestCase): + """host 侧：--resume-note 只贴首轮、不写回存储 goal、不改轮次。""" + + def test_breakpoint_note_first_turn_only_and_rounds_continue(self): + host_mod = _host_mod() + srv = _FakeServer() + with tempfile.TemporaryDirectory() as tmp: + task = {"name": "g", "thread_id": "x", "cwd": tmp, + "sandbox": None, "max_retries": 0, "retry_count": 0, + "turns": [], "status": "goal-running", + "goal_rounds_done": 1} + state, state_path = _host_state(tmp, task) + note = ("[审计推回包（第 1 轮）]\n" + "- [execution_failed] 证据：boom detail") + host_mod.run_goal_loop( + srv, state, state_path, task, "orig goal", "false", + 3, "m", "low", None, start_round=2, + last_verify="", last_turn_status=None, + last_turn_text="", resume_note=note) + self.assertEqual(len(srv.prompts), 2) + self.assertTrue(srv.prompts[0].startswith(note)) + self.assertNotIn("execution_failed", srv.prompts[1]) + # 存储的 goal 不变（备注只是本次续跑首轮的展示前缀）， + # 轮次从断点续接：1（已做）+ 2 轮 = 3，不重置、不跳号。 + self.assertEqual(task["goal"], "orig goal") + self.assertEqual(task["goal_rounds_done"], 3) + self.assertEqual(task["status"], "goal-unmet") + + def test_met_path_note_first_turn_only_and_goal_unchanged(self): + host_mod = _host_mod() + srv = _FakeServer() + with tempfile.TemporaryDirectory() as tmp: + task = {"name": "g", "thread_id": "x", "cwd": tmp, + "sandbox": None, "max_retries": 0, "retry_count": 0, + "turns": []} + state, state_path = _host_state(tmp, task) + note = "[审计推回包（第 1 轮）]\n- [execution_failed]" + result = host_mod.run_goal_loop( + srv, state, state_path, task, "orig goal", "true", + 3, "m", "low", None, resume_note=note) + self.assertTrue(result["ok"]) + self.assertEqual(len(srv.prompts), 1) + self.assertTrue(srv.prompts[0].startswith(note)) + self.assertIn("orig goal", srv.prompts[0]) + self.assertEqual(task["goal"], "orig goal") + + def test_no_note_behavior_unchanged(self): + host_mod = _host_mod() + srv = _FakeServer() + with tempfile.TemporaryDirectory() as tmp: + task = {"name": "g", "thread_id": "x", "cwd": tmp, + "sandbox": None, "max_retries": 0, "retry_count": 0, + "turns": []} + state, state_path = _host_state(tmp, task) + host_mod.run_goal_loop( + srv, state, state_path, task, "orig goal", "true", + 3, "m", "low", None) + self.assertEqual(srv.prompts, ["orig goal"]) + self.assertEqual(task["goal"], "orig goal") + + +class WorkerResumeNoteTests(unittest.TestCase): + """worker 侧：推回 goal 任务经已存在回落走断点续跑时带备注。""" + + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.db_path = os.path.join(self.tmp.name, "control.db") + init_db(self.db_path) + self.env = {"XCM_API_KEY": "test-placeholder"} + self.seen = [] + + def tearDown(self): + self.tmp.cleanup() + + def _worker(self, runner): + return Worker(self.db_path, "/fake/host.py", runner=runner, + env=self.env, max_retries=0, + retry_backoff_seconds=0) + + def _fake_runner(self, cmd): + self.seen.append(list(cmd)) + if "goal-resume" in cmd: + return SimpleNamespace( + returncode=0, + stdout="round 1: turn=completed verify_rc=-\n" + "goal met after rounds\n", + stderr="") + return SimpleNamespace(returncode=0, + stdout="task 已存在", stderr="") + + def test_pushback_goal_fallback_resume_carries_note(self): + _insert_task(self.db_path, "TG", prompt="do goal work", + audit_loop=1, packet=_packet(), goal_mode=1, + goal="orig goal", verify_command="false", + goal_max_rounds=3) + worker = self._worker(self._fake_runner) + result = worker.run_one() + self.assertEqual(result["status"], "completed", result) + # 第一程 goal（撞已存在），第二程断点续跑（带备注）。 + self.assertEqual(len(self.seen), 2) + self.assertIn("goal", self.seen[0]) + self.assertNotIn("goal-resume", self.seen[0]) + resume_cmd = self.seen[1] + self.assertIn("goal-resume", resume_cmd) + self.assertNotIn("--goal-text", resume_cmd) + self.assertIn("--resume-note", resume_cmd) + note = resume_cmd[resume_cmd.index("--resume-note") + 1] + self.assertIn("execution_failed", note) + self.assertIn("boom detail", note) + self.assertIn("task completes", note) + # 库内原 goal / prompt / 验收 / 轮次上限一律不动（备注只 + # 走本次续跑输入，不写回库）。 + row = _row(self.db_path, "TG") + self.assertEqual(row[0], "completed") + self.assertEqual(row[1], "do goal work") + self.assertEqual(row[2], "orig goal") + self.assertEqual(row[3], "false") + self.assertEqual(row[4], 3) + + def test_apply_packet_keeps_goal_columns_and_stashes_note(self): + worker = self._worker(self._fake_runner) + task = {"id": "TG", "project_id": "p1", "prompt": "do goal work", + "goal": "orig goal", "goal_mode": 1, + "verify_command": "false", "goal_max_rounds": 3, + "audit_loop_packet": _packet()} + out = worker._apply_audit_loop_packet(task) + self.assertTrue(out["prompt"].startswith("[审计推回包")) + self.assertIn("execution_failed", out["goal"]) + self.assertEqual(out["verify_command"], "false") + self.assertEqual(out["goal_max_rounds"], 3) + self.assertIn("execution_failed", + out["_audit_loop_resume_note"]) + again = worker._apply_audit_loop_packet(out) + self.assertEqual(again["prompt"].count("execution_failed"), 1) + + def test_non_goal_pushback_unchanged(self): + _insert_task(self.db_path, "TP", prompt="do work", + audit_loop=1, packet=_packet(task_id="TP")) + worker = self._worker(self._fake_runner) + task = worker.get_task("TP") + out = worker._apply_audit_loop_packet(task) + self.assertTrue(out["prompt"].startswith("[审计推回包")) + self.assertIn("execution_failed", out["prompt"]) + # 库内原 prompt 不动（只改内存副本）。 + self.assertEqual(_row(self.db_path, "TP")[1], "do work") + + +class CommandShapeTests(unittest.TestCase): + """命令形状：有备注时含 --resume-note，无备注时无， + goal_text 已设（开新目标）时忽略备注。""" + + def test_local_goal_resume_note_shape(self): + calls = [] + + def fake(cmd): + calls.append(list(cmd)) + return SimpleNamespace( + returncode=0, + stdout="goal met after rounds\n", + stderr="") + + task = {"id": "T1", "project_id": "p1", "prompt": "orig goal", + "verify_command": "true", "goal_max_rounds": 3} + local = LocalExecutor("/fake/host.py", runner=fake) + local.goal_resume_task(task, None, resume_note="NOTE") + self.assertIn("--resume-note", calls[-1]) + self.assertIn("NOTE", calls[-1]) + self.assertNotIn("--goal-text", calls[-1]) + local.goal_resume_task(task, None) + self.assertNotIn("--resume-note", calls[-1]) + local.goal_resume_task(task, "new goal", resume_note="NOTE") + self.assertIn("--goal-text", calls[-1]) + self.assertNotIn("--resume-note", calls[-1]) + + def test_docker_goal_resume_note_shape(self): + calls = [] + + def dfake(cmd, timeout=None): + calls.append(list(cmd)) + return SimpleNamespace( + returncode=0, + stdout="goal met after rounds\n", + stderr="") + + task = {"id": "T1", "project_id": "p1", "prompt": "orig goal", + "verify_command": "true", "goal_max_rounds": 3} + docker = DockerExecutor( + runner=dfake, env={"XCM_API_KEY": "test-placeholder"}) + with mock.patch("cloud.sandbox.shutil.which", + return_value="/usr/bin/docker"): + docker.goal_resume_task(task, None, resume_note="NOTE") + self.assertIn("--resume-note", calls[-1]) + self.assertIn("NOTE", calls[-1]) + with mock.patch("cloud.sandbox.shutil.which", + return_value="/usr/bin/docker"): + docker.goal_resume_task(task, None) + self.assertNotIn("--resume-note", calls[-1]) + with mock.patch("cloud.sandbox.shutil.which", + return_value="/usr/bin/docker"): + docker.goal_resume_task(task, "new goal", + resume_note="NOTE") + self.assertIn("--goal-text", calls[-1]) + self.assertNotIn("--resume-note", calls[-1]) + + def test_popen_goal_resume_breakpoint_note_shape(self): + local = LocalExecutor("/fake/host.py", runner=lambda cmd: None) + with mock.patch.object( + __import__("cloud.sandbox", fromlist=["subprocess"]) + .subprocess, "Popen") as popen: + popen.return_value = SimpleNamespace(pid=9999) + local.popen_task( + {"id": "T1", "prompt": "resume msg", + "_resume_kind": "breakpoint", + "_audit_loop_resume_note": "NOTE"}, + kind="goal-resume") + cmd = popen.call_args[0][0] + self.assertIn("goal-resume", cmd) + self.assertNotIn("--goal-text", cmd) + self.assertIn("--resume-note", cmd) + self.assertIn("NOTE", cmd) + # 无备注的断点续跑：命令形状与旧版一致。 + local.popen_task( + {"id": "T1", "prompt": "resume msg", + "_resume_kind": "breakpoint"}, + kind="goal-resume") + cmd = popen.call_args[0][0] + self.assertNotIn("--resume-note", cmd) + + +if __name__ == "__main__": + unittest.main() diff --git a/cloud/worker.py b/cloud/worker.py index ab8c869..3613f4a 100644 --- a/cloud/worker.py +++ b/cloud/worker.py @@ -2194,10 +2194,12 @@ class Worker: packet 对 goal 任务同步贴两者），但 goal 任务下一轮 实际会撞宿主任务名已存在、经 run_one 的已存在回落走 断点续跑（goal-resume 不传 --goal-text，宿主用存储的 - goal 与 goal_rounds_done+1 继续），所以包前言贴了却 - 不进续跑循环——这是审计推回对 goal 任务的已知效果 - 缺口，不是轮次会计错误，本批不改行为、留待后续批 - 定夺。轮次会计本身有界：审计轮次硬上限 3（MAX_ + goal 与 goal_rounds_done+1 继续）。N-12 修复：认领贴 + 前言时另存 _audit_loop_resume_note，断点续跑时作 + --resume-note 传给 host，host 只贴进本次续跑第一轮的 + prompt，不写回存储的 goal、不改轮次与验收——前言从此 + 到达续跑循环，库内原 goal 与宿主存储的 goal 均不动。 + 轮次会计本身有界：审计轮次硬上限 3（MAX_ PUSHBACKS），3 轮后必升级；goal 旧形态总回合数受 goal_max_rounds 约束（续跑不重置计数），新形态受配额 约束；两组计数器独立、不叠加成无界循环。 @@ -2720,7 +2722,10 @@ class Worker: 顺序是目录树 → 推回包 → 重跑前言 → 项目上下文 → 原 prompt，推回包是最需要 agent 先看到的一段。库里的 原 prompt 与包列都不动，包列只在 pass/escalate 时由 - 接线清理、pushback 时由接线覆盖。 + 接线清理、pushback 时由接线覆盖。另存 + _audit_loop_resume_note（N-12）：同一份前言的副本， + 仅内存键，供断点续跑时作 --resume-note 传给 host； + 非 goal 任务与开新目标续跑忽略它。 """ if task.get("coordinator_parts"): return task @@ -2748,6 +2753,14 @@ class Worker: if task.get("goal_mode") or task.get("verify_command"): new_task["goal"] = preamble + "\n\n" + ( task.get("goal") or task.get("prompt") or "") + # N-12：前言另存一份作断点续跑备注（仅内存键，不进库）。 + # goal 任务下一轮撞“已存在”走断点续跑时，host 只用存储 + # 的原 goal（见 _run_attempt 的 goal_resume 调用），内存 + # goal 里的前言到不了 agent；_run_attempt 在断点续跑时 + # 把这份备注作 --resume-note 传给 host，host 只贴进本次 + # 续跑第一轮的 prompt，不写回存储的 goal。非 goal 任务 + # 与开新目标续跑忽略此键（sandbox 侧的配对守卫）。 + new_task["_audit_loop_resume_note"] = preamble new_task["_audit_loop_packet_injected"] = True self._audit(task["project_id"], "worker_audit_loop_packet_injected", task["id"]) @@ -5553,7 +5566,9 @@ class Worker: network=tenant_network, extra_env=_merge_env(proxy_env, gateway_env), - model_provider=gateway_provider), + model_provider=gateway_provider, + resume_note=task.get( + "_audit_loop_resume_note")), quota_check) else: result = self._docker_call_with_quota_poll( @@ -5620,7 +5635,9 @@ class Worker: result = self.executor.goal_resume_task( task, _resume_text, extra_env=gateway_env, - model_provider=gateway_provider) + model_provider=gateway_provider, + resume_note=task.get( + "_audit_loop_resume_note")) elif isinstance(self.executor, LocalExecutor): result = self.executor.goal_task( task, seed_dir=seed_host_dir, diff --git a/host.py b/host.py index 357ab2a..c19afd0 100644 --- a/host.py +++ b/host.py @@ -1950,7 +1950,8 @@ def _llm_declared_done(text): def run_goal_loop(server, state, state_path, task, goal_text, verify, max_rounds, model, effort, sandbox, cfg=None, timeout=None, verify_timeout=600, start_round=1, - last_verify="", last_turn_status=None, last_turn_text=""): + last_verify="", last_turn_status=None, last_turn_text="", + resume_note=None): """目标循环（长任务版，对齐 Codex App 的可续跑语义）。 两种验收形态（2026-10-27 起，console goal 模式走新形态）： @@ -1980,6 +1981,12 @@ def run_goal_loop(server, state, state_path, task, goal_text, verify, 判 failed，60 分钟工作无续跑口）。 goal-unmet 穷尽轮次后不允许 goal-resume（按既有规则须新建 任务），goal-resume 只接受 goal-running / interrupted / running。 + resume_note（N-12 审计推回前言续跑缺口）：仅断点续跑分支 + 传，贴进本次续跑第一轮的 prompt 最前面（仅展示，不写回 + task["goal"]、不进存储的 goal、不改轮次与验收；后续轮次 + 的 prompt 不再重复贴，同一 thread 的历史里已有它）。不传 + 时行为与旧版逐字相同；开新目标分支绝不传它（新目标自带 + goal_text，不需要也不接受断点备注）。 """ task["goal"] = goal_text task["verify_command"] = verify @@ -2019,6 +2026,9 @@ def run_goal_loop(server, state, state_path, task, goal_text, verify, # max_rounds=0 是不限轮次：while 循环只在模型宣告、预算耗尽 # 或取消时结束；非 0 时按旧语义穷尽轮次即 unmet。 round_no = int(start_round) - 1 + # N-12：断点备注只贴本次续跑的第一轮 prompt（thread 历史 + # 会把它带到后续轮次，不必每轮重复贴、避免 token 膨胀）。 + _first_turn = True # 连续失败轮次护栏：回合瞬间失败（如密钥缺失）时不限轮次 # 循环会无限空转（2026-10-29 实弹：断点后 274 轮全失败， # state 文件持续增长）。3 轮连续失败即走中断出口，任务 @@ -2072,6 +2082,12 @@ def run_goal_loop(server, state, state_path, task, goal_text, verify, f"目标：{goal_text}\n" f"验收命令：{verify}\n" f"上一轮验收输出：\n{last_verify}") + # N-12：断点备注只贴第一轮 prompt（见 _first_turn 注释）， + # 绝不写回 goal_text——task["goal"] 在循环开始时已按原 + # goal_text 落盘，备注只是本次续跑的展示前缀。 + if _first_turn and resume_note: + prompt = "%s\n\n%s" % (resume_note, prompt) + _first_turn = False try: result = run_task_turn(server, state, task, prompt, model, effort, sandbox, timeout=timeout, @@ -2362,6 +2378,10 @@ def main(): "传了会把原验收命令覆盖成 None") p.add_argument("--max-rounds", type=int, default=None, help="不传时沿用原任务的 goal_max_rounds；传了则覆盖总轮次") + p.add_argument("--resume-note", default=None, + help="断点续跑备注（N-12）：仅断点续跑（不传 --goal-text）时用，" + "只贴进本次续跑第一轮的 prompt，不写回存储的 goal、不改" + "轮次与验收；与 --goal-text 同传时忽略（开新目标分支不用它）") p.add_argument("--verify-timeout", type=int, default=600, help="验测命令上限（秒）；0 表示不限时，默认 600") p = sub.add_parser("parallel"); p.add_argument("--jobs", required=True) @@ -3258,7 +3278,8 @@ def main(): start_round=int(t.get("goal_rounds_done") or 0) + 1, last_verify=t.get("goal_last_verify") or "", last_turn_status=t.get("goal_last_turn_status"), - last_turn_text=last_result.get("text", "") or "") + last_turn_text=last_result.get("text", "") or "", + resume_note=args.resume_note) elif args.cmd == "parallel": jobs = json.load(open(args.jobs)) # 依赖 + 优先级：先拓扑排序，缺依赖/成环直接报错不跑；