nccgs 2.0.0-rc.2 → 2.0.0

package/tests/runtime-v15.test.mjs

@@ -6,9 +6,15 @@ import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import test from "node:test";
 import { initializeStandalone, recordStandalone } from "../.claude/nccgs/tools/lifecycle.mjs";
-import { reserve, status, rejectUnclaimed, dispatchPrompt } from "../.claude/nccgs/tools/orchestration.mjs";
+import { reserve, status, rejectUnclaimed, dispatchPrompt, runRepairEditor, reconcile } from "../.claude/nccgs/tools/orchestration.mjs";
+import { repairEditorCommand, unityEditorInvocation } from "../.claude/nccgs/tools/unity-repair.mjs";
+import { settleWorkHandoff } from "../scripts/work-handoff.mjs";
+import { supervise } from "../scripts/supervise.mjs";
+import { registerReviewBudget, reviewBudgetStatus } from "../.claude/nccgs/tools/review-budget.mjs";
+import { startVerification, waitVerification } from "../.claude/nccgs/tools/verification-jobs.mjs";
 import { snapshot } from "../.claude/nccgs/tools/gates.mjs";
 import { observe } from "../.claude/nccgs/tools/runtime.mjs";
+import { captureReturnedHandoff } from "../.claude/nccgs/tools/returned-handoff.mjs";
 import { guardTool } from "../.claude/nccgs/tools/tool-guard.mjs";
 import { artifact, json } from "../.claude/nccgs/tools/policy.mjs";
 import { run as taskRun } from "../.claude/nccgs/tools/task.mjs";
@@ -16,7 +22,7 @@ import { run as taskRun } from "../.claude/nccgs/tools/task.mjs";
 // All envelopes, source files, model identifiers and measurements below are
 // SYNTHETIC TEST FIXTURES. They do not establish actual Claude Code execution.
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-function fixture(mode = "implement", reviewContractRequired = false) {
+function fixture(mode = "implement", reviewContractRequired = false, intakeOverrides = {}) {
   const temporaryRoot = fs.realpathSync(os.tmpdir());
   const project = fs.mkdtempSync(path.join(temporaryRoot, "nccgs-runtime-v15-"));
   const write = (relative, value) => {
@@ -31,7 +37,7 @@ function fixture(mode = "implement", reviewContractRequired = false) {
   write("Assets/fixture.cs", "// SYNTHETIC TEST SOURCE; no game implementation.\n");
   const analysis = ".nccgs/evidence/analysis/synthetic-result.md";
   write(".nccgs/intake.json", { schemaVersion: 1, mode, objective: "SYNTHETIC TEST: inspect bounded fixture behavior", scope: "feature", target: "production-change", readiness: "ready",
-    requiredChecks: ["synthetic-check"], analysisArtifacts: [analysis, ".nccgs/evidence/analysis/synthetic-review.md"], acceptance: [] });
+    requiredChecks: ["synthetic-check"], analysisArtifacts: [analysis, ".nccgs/evidence/analysis/synthetic-review.md"], acceptance: [], ...intakeOverrides });
   initializeStandalone(project, "synthetic", { intake: ".nccgs/intake.json" });
   write(".nccgs/runtime/bindings/synthetic-session.json", { taskId: "synthetic" });
   const verification = write(".nccgs/evidence/synthetic-check.txt", "SYNTHETIC TEST: assertion fixture, not an actual game or provider check.\n");
@@ -71,6 +77,99 @@ function fixture(mode = "implement", reviewContractRequired = false) {
     } };
 }
 
+test("opt-in returned analysis is captured verbatim and pins native identity without closing audit", () => {
+  const f = fixture("audit", true);
+  try {
+    const run = f.dispatch({ agent: "nccgs-engine-programmer", handoffPaths: [f.analysis], handoffTransport: "native-result" });
+    assert.match(dispatchPrompt(f.project, "synthetic", run.reservation.id).prompt, /sole final text response/);
+    f.start(run);
+    assert.throws(() => guardTool(f.project, { session_id: "synthetic-session", agent_id: run.agentId, tool_name: "Write",
+      tool_input: { file_path: path.join(f.project, f.analysis), content: "forged" } }), /captured only/);
+    const text = "NCCGS-HANDOFF: COMPLETE\n\nSYNTHETIC factual analysis. No source edits; not independent review.\n";
+    const envelope = f.result(run, { content: [{ type: "text", text }] });
+    const observation = observe(f.project, envelope, "agent_result");
+    assert.equal(fs.readFileSync(path.join(f.project, f.analysis), "utf8"), text);
+    assert.equal(f.state().reservations[0].status, "completed");
+    assert.deepEqual(observation.returnedHandoff.evidence, artifact(f.project, f.analysis));
+    recordStandalone(f.project, f.task(), "analysis", { ...f.stage(run, observation), evidence: artifact(f.project, f.analysis) });
+    assert.ok(!f.task().closed);
+    assert.ok(observe(f.project, envelope, "agent_result").duplicate);
+    const reviewPath = ".nccgs/evidence/analysis/synthetic-review.md";
+    const review = f.dispatch({ kind: "review", agent: "nccgs-adversarial-reviewer", writePaths: [], handoffPaths: [reviewPath], handoffTransport: "native-result" });
+    f.start(review);
+    const verdict = { schemaVersion: 1, taskId: "synthetic", contractHash: f.task().contractHash, snapshot: review.reservation.snapshot,
+      verdict: "BLOCKED", criteriaMet: false, findings: [], conditions: [{ id: "R1", description: "Synthetic required check remains unresolved." }] };
+    const reviewText = "NCCGS-HANDOFF: COMPLETE\n\n```nccgs-review\n" + JSON.stringify(verdict) + "\n```\n";
+    const observedReview = observe(f.project, f.result(review, { content: [{ type: "text", text: reviewText }] }), "agent_result");
+    assert.equal(fs.readFileSync(path.join(f.project, reviewPath), "utf8"), reviewText);
+    assert.equal(f.state().reservations[1].status, "completed");
+    assert.throws(() => recordStandalone(f.project, f.task(), "review", { ...f.stage(review, observedReview), evidence: artifact(f.project, reviewPath),
+      ...verdict, verdict: "PASS", criteriaMet: true, conditions: [] }), /differs from.*handoff/);
+    assert.ok(!f.task().closed);
+  } finally { f.dispose(); }
+});
+
+for (const scenario of ["partial", "missing", "multiple", "oversized", "incomplete", "existing", "source-change"]) test(`returned handoff fails closed: ${scenario}`, () => {
+  const f = fixture("audit", true);
+  try {
+    const run = f.dispatch({ agent: "nccgs-engine-programmer", handoffPaths: [f.analysis], handoffTransport: "native-result" }); f.start(run);
+    const text = "NCCGS-HANDOFF: COMPLETE\nSYNTHETIC returned content.\n";
+    let content = [{ type: "text", text }], extra = {};
+    if (scenario === "partial") content[0].text = text.replace("COMPLETE", "PARTIAL");
+    if (scenario === "missing") content = "not a supported native content envelope";
+    if (scenario === "multiple") content.push({ type: "text", text: "extra" });
+    if (scenario === "oversized") content[0].text += "x".repeat(262144);
+    if (scenario === "incomplete") extra = { harnessNoteCount: 1 };
+    if (scenario === "existing") f.write(f.analysis, "NCCGS-HANDOFF: COMPLETE\nPreserved existing bytes.\n");
+    if (scenario === "source-change") f.write("Assets/fixture.cs", "// SYNTHETIC forbidden mutation.\n");
+    observe(f.project, f.result(run, { content, ...extra }), "agent_result");
+    assert.equal(f.state().reservations[0].status, "failed");
+    if (scenario === "existing") assert.match(fs.readFileSync(path.join(f.project, f.analysis), "utf8"), /Preserved existing/);
+    else if (scenario !== "partial") assert.ok(!fs.existsSync(path.join(f.project, f.analysis)));
+    assert.ok(!f.task().closed);
+  } finally { f.dispose(); }
+});
+
+test("returned handoff cannot be requested for source writers, multiple paths or unknown transport", () => {
+  const f = fixture();
+  try {
+    assert.throws(() => f.dispatch({ handoffPaths: [f.analysis], handoffTransport: "native-result" }), /read-only artifact/);
+    assert.throws(() => f.dispatch({ handoffTransport: "invented" }), /Unknown handoff transport/);
+    assert.equal(f.state().usage.dispatches, 0);
+  } finally { f.dispose(); }
+  const a = fixture("audit");
+  try {
+    assert.throws(() => a.dispatch({ handoffTransport: "native-result", handoffPaths: [a.analysis, ".nccgs/evidence/analysis/synthetic-review.md"] }), /one declared/);
+    assert.equal(a.state().usage.dispatches, 0);
+  } finally { a.dispose(); }
+});
+
+test("native-result transport rejects mismatched hook identities without publishing", () => {
+  const f = fixture("audit");
+  try {
+    const run = f.dispatch({ handoffPaths: [f.analysis], handoffTransport: "native-result" }); f.start(run);
+    const dispatch = f.state().reservations[0], base = f.result(run, { content: [{ type: "text", text: "NCCGS-HANDOFF: COMPLETE\nSYNTHETIC" }] });
+    for (const field of ["session_id", "tool_use_id", "hook_event_name", "tool_name"]) {
+      const result = captureReturnedHandoff(f.project, dispatch, { ...base, [field]: "incorrect" }, { status: "completed" }, dispatch.snapshot);
+      assert.equal(result.status, "rejected");
+    }
+    for (const envelope of [{ ...base, tool_response: { ...base.tool_response, agentId: "wrong" } },
+      { ...base, tool_input: { ...base.tool_input, subagent_type: "wrong" } }])
+      assert.equal(captureReturnedHandoff(f.project, dispatch, envelope, { status: "completed" }, dispatch.snapshot).status, "rejected");
+    assert.ok(!fs.existsSync(path.join(f.project, f.analysis)));
+  } finally { f.dispose(); }
+});
+
+test("legacy file transport never captures arbitrary native response content", () => {
+  const f = fixture("audit");
+  try {
+    const run = f.dispatch({ handoffPaths: [f.analysis] }); f.start(run);
+    observe(f.project, f.result(run, { content: [{ type: "text", text: "NCCGS-HANDOFF: COMPLETE\nSYNTHETIC" }] }), "agent_result");
+    assert.equal(f.state().reservations[0].status, "failed");
+    assert.ok(!fs.existsSync(path.join(f.project, f.analysis)));
+  } finally { f.dispose(); }
+});
+
 test("synthetic foreground native result completes a reserved dispatch and records lifecycle output", () => {
   const f = fixture();
   try {
@@ -312,6 +411,379 @@ function repairCall(f, run, id, name = "Read", tool = { file_path: "Assets/fixtu
   return { hook_event_name: "PreToolUse", session_id: "synthetic-session", agent_id: run.agentId, tool_use_id: id, tool_name: name, tool_input: tool };
 }
 
+function prepareUnityRepair(f, type = "unity-code", create = false, steps = 1) {
+  f.write("ProjectSettings/ProjectVersion.txt", "m_EditorVersion: SYNTHETIC-FIXTURE\n");
+  f.write("Assets/fixture.cs.meta", "fileFormatVersion: 2\nguid: 11111111111111111111111111111111\n");
+  const target = type === "unity-editor" ? "Assets/Fixture.prefab" : create ? "Assets/Regression.cs" : "Assets/fixture.cs";
+  if (type === "unity-editor" && !create) {
+    f.write(target, "%YAML SYNTHETIC FIXTURE; not a real Unity prefab\n");
+    f.write(`${target}.meta`, "fileFormatVersion: 2\nguid: 22222222222222222222222222222222\n");
+  }
+  const capabilities = f.write(".nccgs/evidence/unity-capabilities.txt", "SYNTHETIC CLI catalog fixture; no Unity or provider execution. synthetic_operation(positionals)\n");
+  const old = prepareRepair(f);
+  const packet = { ...old.packet, schemaVersion: 2, repairType: type,
+    changes: [{ path: target, operation: create ? "create" : "edit", instruction: "Apply only the synthetic fixture change" }],
+    unity: { capabilities, steps: Array.from({ length: steps }, (_, i) => ({ id: `step-${i + 1}`, command: "eval", arguments: ['return "SYNTHETIC ONLY";'], timeoutMs: 1000 })) } };
+  f.write(old.request.workPacket, packet);
+  return { packet, target, request: { ...old.request, writePaths: [target] } };
+}
+function editorCall(f, run, step, id = step.id) {
+  return repairCall(f, run, id, "Bash", { command: repairEditorCommand(run.reservation, step), timeout: step.timeoutMs + 5000 });
+}
+const syntheticEditorSuccess = () => ({ status: 0, stdout: '{"synthetic":true}', stderr: "" });
+
+test("dirty-scene refusal is a retained failed attempt, with no automatic retry, source change or review waiver", () => {
+  const f = fixture();
+  try {
+    const { packet, request, target } = prepareUnityRepair(f, "unity-editor"), run = f.dispatch(request); f.start(run);
+    const before = fs.readFileSync(path.join(f.project, target));
+    guardTool(f.project, editorCall(f, run, packet.unity.steps[0]));
+    const receipt = runRepairEditor(f.project, "synthetic", run.reservation.id, "step-1", (exe, args) => {
+      const token = args[2].match(/token = "([a-f0-9-]+)"/)[1];
+      return { status: 0, stdout: JSON.stringify({ success: true, data: { result: { success: true,
+        result: { nccgsSceneGuard: "loaded-scenes-clean-v1", token, blockedScene: "<untitled>" } } } }), stderr: "" };
+    });
+    assert.equal(receipt.status, "FAIL"); assert.equal(receipt.operationStatus, "failed");
+    assert.match(receipt.message, /Unsaved scene/);
+    assert.equal(json(path.join(f.project, receipt.evidence.path)).blockedScene, "<untitled>");
+    assert.deepEqual(fs.readFileSync(path.join(f.project, target)), before);
+    assert.throws(() => runRepairEditor(f.project, "synthetic", run.reservation.id, "step-1", syntheticEditorSuccess), /already attempted/);
+    f.write(request.handoffPaths[0], "NCCGS-HANDOFF: PARTIAL\nUnsaved scene; owner action needed.");
+    observe(f.project, f.result(run), "agent_result");
+    assert.equal(f.state().usage.dispatches, 3);
+    assert.equal(f.state().active.length, 0);
+    assert.equal(f.task().stages.review.verdict, "CHANGES_REQUIRED");
+  } finally { f.dispose(); }
+});
+
+test("previously pinned Unity reservations retain their original operation without retroactive guard injection", () => {
+  const f = fixture();
+  try {
+    const { packet, request } = prepareUnityRepair(f), run = f.dispatch(request);
+    const file = path.join(f.project, ".nccgs/orchestration.json"), ledger = json(file);
+    delete ledger.dispatches[run.reservation.id].workPacket.sceneSafety; // Pre-RC4 reservation fixture.
+    fs.writeFileSync(file, JSON.stringify(ledger)); f.start(run);
+    guardTool(f.project, editorCall(f, run, packet.unity.steps[0]));
+    const receipt = runRepairEditor(f.project, "synthetic", run.reservation.id, "step-1", (exe, args) => {
+      assert.equal(args[2], packet.unity.steps[0].arguments[0]); return syntheticEditorSuccess();
+    });
+    assert.equal(receipt.operationStatus, "completed");
+    assert.equal(json(path.join(f.project, receipt.evidence.path)).sceneGuard, undefined);
+    assert.throws(() => unityEditorInvocation(f.project, packet.unity.steps[0], "unknown-policy"), /unknown pinned/);
+  } finally { f.dispose(); }
+});
+
+test("work handoff records PARTIAL only with current output and never changes review, acceptance, history or spent quota", () => {
+  for (const variant of ["ready", "stale", "failed-check", "unmeasured", "reported", "no-allocation", "final-review", "unknown-cost", "active"]) {
+    const f = fixture("implement", false, { manualGates: ["OWNER-01"], ...(variant === "unmeasured" ? {
+      acceptance: [{ id: "UNMEASURED", check: "synthetic-check", description: "Missing measured evidence" }]
+    } : {}) });
+    try {
+      const work = f.dispatch(); f.start(work); const observed = observe(f.project, f.result(work), "agent_result");
+      recordStandalone(f.project, f.task(), "implementation", f.stage(work, observed));
+      const state = { id: "synthetic-run", taskId: "synthetic", contractHash: f.task().contractHash, createdAt: f.task().createdAt,
+        budgetAllocation: { synthetic: true }, budgetPhase: "work", costCoverage: "complete", invocations: [{ status: "finished", code: 0, terminal: { type: "result" } }] };
+      if (variant === "stale") f.write("Assets/fixture.cs", "// changed after verification");
+      if (variant === "failed-check") {
+        const task = f.task();
+        task.stages.implementation.checks[0].status = "FAIL";
+        f.write(".nccgs/tasks/synthetic.json", task);
+      }
+      if (variant === "reported") recordStandalone(f.project, f.task(), "report", { outcome: "blocked", summary: "Preserve explicit coordinator assessment" });
+      if (variant === "no-allocation") delete state.budgetAllocation;
+      if (variant === "final-review") state.budgetPhase = "final-review";
+      if (variant === "unknown-cost") state.costCoverage = "unknown-current-invocation";
+      if (variant === "active") f.dispatch({ kind: "review", agent: "nccgs-adversarial-reviewer", writePaths: [] });
+      const before = f.task(), ledger = fs.readFileSync(path.join(f.project, ".nccgs/orchestration.json"));
+      const result = settleWorkHandoff(f.project, state);
+      if (variant === "ready") {
+        assert.ok(result); assert.equal(f.task().outcome, "partial");
+        assert.equal(f.task().stages.report.origin, "supervisor-work-handoff");
+        assert.equal(f.task().stages.review, undefined); assert.equal(f.task().closed, undefined);
+        assert.deepEqual(f.task().contract, before.contract); assert.deepEqual(f.task().reviewBudget, before.reviewBudget);
+        assert.deepEqual(f.task().history.slice(0, before.history.length), before.history);
+        assert.equal(settleWorkHandoff(f.project, state), null);
+        assert.throws(() => taskRun(["close", "--project", f.project, "--id", "synthetic"]), /review.*missing|stale/i);
+      } else { assert.equal(result, null, variant); assert.deepEqual(f.task(), before, variant); }
+      assert.deepEqual(fs.readFileSync(path.join(f.project, ".nccgs/orchestration.json")), ledger);
+    } finally { f.dispose(); }
+  }
+});
+
+test("protected work supervisor settles a prose-only PARTIAL without spending a continuation or final-review reserve", async () => {
+  const f = fixture();
+  try {
+    fs.cpSync(path.join(root, ".claude/nccgs/tools"), path.join(f.project, ".claude/nccgs/tools"), { recursive: true });
+    f.write(".nccgs/evidence/budget.json", { schemaVersion: 1, authority: "Synthetic fixture only", totalUsd: 1, finalReviewUsd: 0.4, totalDurationMs: 60000, finalReviewDurationMs: 10000 });
+    registerReviewBudget(f.project, "synthetic", ".nccgs/evidence/budget.json");
+    f.write(".nccgs/native-fixture.mjs", `import {reserve} from '../.claude/nccgs/tools/orchestration.mjs';
+import {guardTool} from '../.claude/nccgs/tools/tool-guard.mjs';
+import {observe} from '../.claude/nccgs/tools/runtime.mjs';
+import {record} from '../.claude/nccgs/tools/gates.mjs';
+import {artifact} from '../.claude/nccgs/tools/policy.mjs';
+const project=process.cwd(), session=process.env.NCCGS_SUPERVISED_SESSION;
+const d=reserve(project,'synthetic',{kind:'implementation',agent:'nccgs-gameplay-programmer',requestKey:'once',reason:'SYNTHETIC',writePaths:['Assets/fixture.cs']});
+const input={session_id:session,tool_name:'Agent',tool_use_id:'synthetic-tool',tool_input:{subagent_type:d.agent,prompt:'[NCCGS-DISPATCH:'+d.id+'] SYNTHETIC'}};
+guardTool(project,input);observe(project,{session_id:session,agent_id:'synthetic-worker',agent_type:d.agent},'agent_start');
+const o=observe(project,{...input,tool_response:{agentId:'synthetic-worker',status:'completed',resolvedModel:'claude-opus-5-5',totalDurationMs:123,totalToolUseCount:2,totalTokens:456}},'agent_result');
+record(project,'synthetic','implementation',{snapshot:o.snapshot,dispatchId:d.id,runtime:artifact(project,o.path),checks:[{name:'synthetic-check',status:'PASS',evidence:artifact(project,'.nccgs/evidence/synthetic-check.txt')}]});
+console.log(JSON.stringify({type:'result',session_id:session,total_cost_usd:0.2,result:'PARTIAL: ready for independent review. Synthetic provider fixture only.'}));`);
+    f.write(".nccgs/prompt.txt", "SYNTHETIC provider integration test; no Claude execution");
+    const env = { ...process.env }; for (const key of ["NCCGS_SUPERVISED_RUN", "NCCGS_SUPERVISED_SESSION", "NCCGS_TASK_ID", "CLAUDECODE"]) delete env[key];
+    const plan = { project: f.project, binary: process.execPath, mode: "full", args: [path.join(f.project, ".nccgs/native-fixture.mjs")], env,
+      supervision: { taskId: "synthetic", promptFile: path.join(f.project, ".nccgs/prompt.txt"), budgetUsd: 1, maxResumes: 0, timeoutMs: 20000, budgetPhase: "work" } };
+    assert.equal(await supervise(plan), 0);
+    const id = fs.readdirSync(path.join(f.project, ".nccgs/runs"), { withFileTypes: true }).find(e => e.isDirectory()).name;
+    const run = json(path.join(f.project, `.nccgs/runs/${id}/run.json`));
+    assert.equal(run.invocations.length, 1); assert.equal(run.cumulativeCostUsd, 0.2); assert.equal(run.taskOutcome, "partial");
+    assert.equal(run.workHandoff.origin, "supervisor-work-handoff"); assert.equal(f.task().stages.review, undefined);
+    assert.equal(reviewBudgetStatus(f.project, "synthetic").protectedReviewUsd, 0.4);
+    const history = f.task().history;
+    assert.equal(await supervise({ ...plan, supervision: { recoverRun: id } }), 0);
+    assert.deepEqual(f.task().history, history); assert.equal(f.state().usage.dispatches, 1);
+  } finally { f.dispose(); }
+});
+
+test("work handoff rejects the latest failed check even when an older PASS was recorded again", () => {
+  const f = fixture();
+  try {
+    const state = { id: "synthetic-run", taskId: "synthetic", contractHash: f.task().contractHash, createdAt: f.task().createdAt,
+      budgetAllocation: { synthetic: true }, budgetPhase: "work", costCoverage: "complete", invocations: [{ status: "finished", code: 0, terminal: { type: "result" } }] };
+    for (const exitCode of [1, 0]) {
+      const work = f.dispatch(); f.start(work); const observed = observe(f.project, f.result(work), "agent_result");
+      const started = startVerification(f.project, "synthetic", { name: "synthetic-check", executable: process.execPath, arguments: ["-e", `process.exit(${exitCode})`] });
+      const receipt = waitVerification(f.project, started.jobId, "synthetic", 10000);
+      assert.equal(receipt.status, exitCode ? "FAIL" : "PASS");
+      recordStandalone(f.project, f.task(), "implementation", f.stage(work, observed));
+      const report = settleWorkHandoff(f.project, state);
+      if (exitCode) assert.equal(report, null); else assert.ok(report);
+    }
+  } finally { f.dispose(); }
+});
+
+test("Unity repair creates code and imports metadata before completion, retaining negative history and manual gates", () => {
+  const f = fixture("implement", false, { manualGates: ["OWNER-01"] });
+  try {
+    const { packet, request, target } = prepareUnityRepair(f, "unity-code", true);
+    const original = f.task(), feedback = fs.readFileSync(path.join(f.project, f.analysis));
+    const run = f.dispatch(request); f.start(run);
+    assert.equal(run.reservation.workPacket.budget.workCalls, 24);
+    assert.equal(run.reservation.workPacket.budget.readCalls, 12);
+    assert.match(dispatchPrompt(f.project, "synthetic", run.reservation.id).prompt, /Never hand-write \.meta/);
+    assert.throws(() => runRepairEditor(f.project, "synthetic", run.reservation.id, "step-1", syntheticEditorSuccess), /tool admission/);
+    guardTool(f.project, repairCall(f, run, "new-code", "Write", { file_path: target }));
+    f.write(target, "// SYNTHETIC new test source; no Unity execution\n");
+    const call = editorCall(f, run, packet.unity.steps[0]);
+    guardTool(f.project, call);
+    const result = runRepairEditor(f.project, "synthetic", run.reservation.id, "step-1", (executable, args, options) => {
+      assert.match(executable, /^unity(?:\.exe)?$/); assert.equal(options.shell, false); assert.equal(options.windowsHide, true);
+      assert.equal(args[args.indexOf("--project-path") + 1], fs.realpathSync(f.project));
+      assert.deepEqual(args.slice(0, 2), ["command", "eval"]);
+      assert.match(args[2], /GetSceneAt.*isDirty/s);
+      assert.ok(args[2].endsWith('return "SYNTHETIC ONLY";'));
+      f.write(`${target}.meta`, "fileFormatVersion: 2\nguid: 33333333333333333333333333333333\n");
+      return syntheticEditorSuccess();
+    });
+    assert.equal(result.status, "EXECUTED");
+    assert.equal(json(path.join(f.project, result.evidence.path)).origin, "unity-repair-operation");
+    f.write(request.handoffPaths[0], "NCCGS-HANDOFF: COMPLETE\nSynthetic edit/import completed; verification remains separate.");
+    const observed = observe(f.project, f.result(run), "agent_result");
+    assert.equal(f.state().reservations.at(-1).status, "completed");
+    assert.throws(() => recordStandalone(f.project, f.task(), "implementation", { ...f.stage(run, observed),
+      checks: [{ name: "synthetic-check", status: "PASS", evidence: result.evidence }] }), /operation receipts are not verification/);
+    recordStandalone(f.project, f.task(), "implementation", f.stage(run, observed));
+    assert.deepEqual(f.task().contract, original.contract);
+    assert.equal(f.task().reviewBudget.used, original.reviewBudget.used);
+    assert.ok(f.task().history.some(h => h.stages?.review?.verdict === "CHANGES_REQUIRED"));
+    assert.deepEqual(fs.readFileSync(path.join(f.project, f.analysis)), feedback);
+    assert.throws(() => recordStandalone(f.project, f.task(), "report", { outcome: "success", summary: "Cannot skip fresh review" }), /review.*missing|stale/i);
+    const review = f.dispatch({ kind: "review", agent: "nccgs-adversarial-reviewer", writePaths: [] }); f.start(review);
+    const reviewed = observe(f.project, f.result(review), "agent_result");
+    const evidence = f.write(".nccgs/evidence/analysis/synthetic-review.md", "SYNTHETIC independent review, not actual provider evidence");
+    recordStandalone(f.project, f.task(), "review", { snapshot: reviewed.snapshot, dispatchId: review.reservation.id,
+      runtime: artifact(f.project, reviewed.path), verdict: "PASS", criteriaMet: true, findings: [], evidence });
+    recordStandalone(f.project, f.task(), "report", { outcome: "success", summary: "Synthetic technical pass; manual decision pending" });
+    assert.throws(() => taskRun(["close", "--project", f.project, "--id", "synthetic"]), /acceptance: missing/);
+    assert.equal(f.state().usage.dispatches, 4); assert.equal(f.task().reviewBudget.used, original.reviewBudget.used + 1);
+  } finally { f.dispose(); }
+});
+
+test("Unity repair Editor operations are pinned, ordered, exclusive and never replayed", () => {
+  const f = fixture();
+  try {
+    const { packet, request, target } = prepareUnityRepair(f, "unity-editor", false, 2);
+    packet.changes.push({ path: "Assets/fixture.cs", operation: "edit", instruction: "SYNTHETIC paired code correction for the prefab" });
+    request.writePaths.push("Assets/fixture.cs"); f.write(request.workPacket, packet);
+    const run = f.dispatch(request); f.start(run);
+    guardTool(f.project, repairCall(f, run, "paired-code", "Edit", { file_path: "Assets/fixture.cs" }));
+    f.write("Assets/fixture.cs", "// SYNTHETIC code correction paired with the prefab\n");
+    assert.throws(() => f.dispatch({ writePaths: ["Assets/elsewhere.cs"] }), /owns the project/);
+    for (const input of [
+      repairCall(f, run, "raw", "Write", { file_path: target }),
+      repairCall(f, run, "meta", "Edit", { file_path: `${target}.meta` }),
+      repairCall(f, run, "shell", "Bash", { command: "unity command eval evil", timeout: 6000 }),
+      repairCall(f, run, "mcp", "mcp__unityMCP__execute_code", { code: "unbounded" }),
+      { ...editorCall(f, run, packet.unity.steps[0], "background"), tool_input: { ...editorCall(f, run, packet.unity.steps[0]).tool_input, run_in_background: true } },
+      { ...editorCall(f, run, packet.unity.steps[0], "chain"), tool_input: { command: repairEditorCommand(run.reservation, packet.unity.steps[0]) + "; echo bad", timeout: 6000 } },
+      { ...editorCall(f, run, packet.unity.steps[0], "short"), tool_input: { command: repairEditorCommand(run.reservation, packet.unity.steps[0]), timeout: 1000 } }
+    ]) assert.throws(() => guardTool(f.project, input));
+    assert.throws(() => runRepairEditor(f.project, "synthetic", run.reservation.id, "step-2", syntheticEditorSuccess), /packet order/);
+    guardTool(f.project, editorCall(f, run, packet.unity.steps[0]));
+    let executions = 0;
+    const executor = () => { executions++; f.write(target, "%YAML SYNTHETIC changed through fake Editor\n"); return syntheticEditorSuccess(); };
+    const receipt = runRepairEditor(f.project, "synthetic", run.reservation.id, "step-1", executor);
+    assert.throws(() => runRepairEditor(f.project, "synthetic", run.reservation.id, "step-1", executor), /already attempted/);
+    assert.equal(executions, 1);
+    for (const file_path of [receipt.evidence.path, run.reservation.workPacket.scope.path, packet.unity.capabilities.path])
+      assert.throws(() => guardTool(f.project, { session_id: "synthetic-session", tool_name: "Write", tool_input: { file_path } }), /immutable/);
+    guardTool(f.project, editorCall(f, run, packet.unity.steps[1]));
+    runRepairEditor(f.project, "synthetic", run.reservation.id, "step-2", syntheticEditorSuccess);
+    f.write(request.handoffPaths[0], "NCCGS-HANDOFF: COMPLETE\nSYNTHETIC saved asset");
+    const observed = observe(f.project, f.result(run), "agent_result");
+    assert.equal(f.state().reservations.at(-1).status, "completed");
+    f.write(receipt.evidence.path, "SYNTHETIC tampering");
+    assert.throws(() => recordStandalone(f.project, f.task(), "implementation", f.stage(run, observed)), /stale artifact/);
+  } finally { f.dispose(); }
+});
+
+test("Unity repair rejects malformed profiles and scope before consuming another dispatch", () => {
+  const f = fixture();
+  try {
+    const { packet, request } = prepareUnityRepair(f);
+    const invalid = [
+      { ...packet, repairType: "unrestricted" }, { ...packet, budget: { workCalls: 25 } },
+      { ...packet, changes: [{ ...packet.changes[0], operation: "delete" }] },
+      { ...packet, changes: [{ ...packet.changes[0], operation: "create" }] },
+      { ...packet, changes: [{ ...packet.changes[0], path: "Assets/fixture.cs.meta" }] },
+      { ...packet, changes: [{ ...packet.changes[0], path: "Packages/manifest.json" }] },
+      { ...packet, changes: [{ ...packet.changes[0], path: "Assets/missing/new.cs", operation: "create" }] },
+      { ...packet, unity: { ...packet.unity, capabilities: { ...packet.unity.capabilities, sha256: "changed" } } },
+      ...[{ arguments: ["--project-path", "/other"] }, { command: "eval;evil" }, { command: "scene_open" }, { arguments: ["one", "two"] },
+        { arguments: ['using UnityEngine;\nreturn "bad";'] }, { timeoutMs: 60001 }, { id: "../x" }, { unknown: true }]
+        .map(override => ({ ...packet, unity: { ...packet.unity, steps: [{ ...packet.unity.steps[0], ...override }] } }))
+    ];
+    const before = fs.readFileSync(path.join(f.project, ".nccgs/orchestration.json"));
+    for (const bad of invalid) {
+      f.write(request.workPacket, bad); assert.throws(() => f.dispatch(request));
+      assert.deepEqual(fs.readFileSync(path.join(f.project, ".nccgs/orchestration.json")), before);
+    }
+    f.write(request.workPacket, packet);
+    const run = f.dispatch(request);
+    const same = reserve(f.project, "synthetic", run.request);
+    assert.equal(same.id, run.reservation.id); assert.equal(f.state().usage.dispatches, 3);
+  } finally { f.dispose(); }
+});
+
+test("Unity repair refuses out-of-scope side effects, changed GUIDs and unfinished import", () => {
+  for (const variant of ["outside", "deleted", "guid", "missing-meta", "missing-step"]) {
+    const f = fixture();
+    try {
+      const { packet, request, target } = prepareUnityRepair(f, "unity-code", variant === "missing-meta"), run = f.dispatch(request); f.start(run);
+      if (variant === "missing-step") {
+        f.write(request.handoffPaths[0], "NCCGS-HANDOFF: COMPLETE\nSYNTHETIC false completion");
+      } else {
+        guardTool(f.project, editorCall(f, run, packet.unity.steps[0]));
+        const result = runRepairEditor(f.project, "synthetic", run.reservation.id, "step-1", () => {
+          if (variant === "outside") f.write("Assets/Unowned.cs", "// synthetic unexpected import side effect");
+          if (variant === "deleted") fs.unlinkSync(path.join(f.project, "Assets/fixture.cs"));
+          if (variant === "guid") f.write("Assets/fixture.cs.meta", "guid: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n");
+          if (variant === "missing-meta") f.write(target, "// synthetic new file without imported metadata");
+          return syntheticEditorSuccess();
+        });
+        assert.equal(result.operationStatus, variant === "missing-meta" ? "completed" : "failed");
+        f.write(request.handoffPaths[0], "NCCGS-HANDOFF: COMPLETE\nSYNTHETIC false completion");
+      }
+      const observed = observe(f.project, f.result(run), "agent_result");
+      assert.equal(f.state().reservations.at(-1).status, "failed", variant);
+      assert.throws(() => recordStandalone(f.project, f.task(), "implementation", f.stage(run, observed)), /completed managed dispatch/);
+      assert.equal(f.state().usage.dispatches, 3); assert.equal(f.task().stages.review.verdict, "CHANGES_REQUIRED");
+    } finally { f.dispose(); }
+  }
+});
+
+test("Unity repair interruption retains ownership, partial evidence and spent attempts", () => {
+  for (const variant of ["timeout", "signal", "nonzero", "missing-cli"]) {
+    const f = fixture();
+    try {
+      const { packet, request } = prepareUnityRepair(f), run = f.dispatch(request); f.start(run);
+      guardTool(f.project, editorCall(f, run, packet.unity.steps[0]));
+      const error = Object.assign(new Error("SYNTHETIC interrupted editor operation"), { code: variant === "missing-cli" ? "ENOENT" : "ETIMEDOUT" });
+      const result = runRepairEditor(f.project, "synthetic", run.reservation.id, "step-1", () => variant === "signal" ? { status: null, signal: "SIGTERM" }
+        : variant === "nonzero" ? { status: 6 } : { status: null, error });
+      assert.equal(result.status, "FAIL");
+      assert.throws(() => guardTool(f.project, repairCall(f, run, "read-after-failure")), /running, correlated|failed or remains uncertain/);
+      const partial = "NCCGS-HANDOFF: PARTIAL\nSYNTHETIC interrupted Editor operation; retain original attempt";
+      guardTool(f.project, repairCall(f, run, "partial", "Write", { file_path: request.handoffPaths[0], content: partial }));
+      f.write(request.handoffPaths[0], partial);
+      if (variant !== "missing-cli") {
+        assert.equal(f.state().reservations.at(-1).status, "uncertain");
+        const observed = observe(f.project, f.result(run), "agent_result");
+        const retained = f.state().reservations.at(-1);
+        assert.equal(retained.status, "uncertain"); assert.equal(retained.workStatus, "incomplete-editor");
+        assert.equal(retained.telemetry.totalTokens, 456); assert.equal(retained.telemetry.durationMs, 123);
+        assert.equal(retained.runtime.path, observed.path);
+        assert.equal(observe(f.project, f.result(run), "agent_result").duplicate, true);
+        assert.throws(() => recordStandalone(f.project, f.task(), "implementation", f.stage(run, observed)), /handoff is partial|completed managed dispatch/);
+        assert.throws(() => f.dispatch(), /owns the project/);
+        reconcile(f.project, run.reservation.id, { status: "failed", reason: "SYNTHETIC external operator confirmed the fake operation stopped", reference: "SYNTHETIC TEST ONLY" });
+      } else observe(f.project, f.result(run), "agent_result");
+      assert.equal(f.state().usage.dispatches, 3); assert.equal(f.state().active.length, 0);
+      assert.equal(fs.readFileSync(path.join(f.project, request.handoffPaths[0]), "utf8"), partial);
+      assert.ok(f.state().reservations.at(-1).editorSteps[0].evidence);
+      assert.equal(f.state().reservations.at(-1).telemetry.totalTokens, 456);
+    } finally { f.dispose(); }
+  }
+});
+
+test("Unity repair CLI rejects caller-supplied commands, duplicate flags and forwarded payloads", () => {
+  const f = fixture();
+  try {
+    const base = ["repair-editor", "--project", f.project, "--id", "synthetic", "--dispatch", "synthetic", "--step", "one"];
+    for (const extra of [["--command", "evil"], ["--step", "two"], ["--", "unity"], ["--timeout", "999999"]])
+      assert.throws(() => taskRun([...base, ...extra]), /unique.*no forwarded/);
+  } finally { f.dispose(); }
+});
+
+test("Unity repair executable hook and CLI retain a missing-tool failure without launching Unity", () => {
+  const f = fixture();
+  try {
+    const { packet, request } = prepareUnityRepair(f), run = f.dispatch(request); f.start(run);
+    const admitted = f.hook("closure-guard.mjs", "pre", editorCall(f, run, packet.unity.steps[0]));
+    assert.equal(admitted.status, 0, admitted.stderr);
+    const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => key.toLowerCase() !== "path"));
+    env.PATH = f.project; // No unity executable in this disposable synthetic fixture.
+    const child = spawnSync(process.execPath, [path.join(root, ".claude/nccgs/tools/task.mjs"), "repair-editor", "--project", f.project,
+      "--id", "synthetic", "--dispatch", run.reservation.id, "--step", "step-1"], { cwd: f.project, env, windowsHide: true, encoding: "utf8" });
+    assert.equal(child.status, 1, child.stderr);
+    const response = JSON.parse(child.stdout);
+    assert.equal(response.operationStatus, "failed");
+    assert.match(json(path.join(f.project, response.evidence.path)).error, /ENOENT/);
+    assert.equal(f.state().reservations.at(-1).editorSteps.length, 1);
+    assert.equal(f.state().usage.dispatches, 3);
+  } finally { f.dispose(); }
+});
+
+test("Unity repair code-only profile does not require Editor availability for existing files", () => {
+  const f = fixture();
+  try {
+    const { packet, request, target } = prepareUnityRepair(f, "unity-code", false, 0);
+    delete packet.unity.capabilities;
+    f.write(request.workPacket, packet);
+    const run = f.dispatch(request); f.start(run);
+    const prompt = dispatchPrompt(f.project, "synthetic", run.reservation.id).prompt;
+    assert.match(prompt, /No Editor steps are reserved/); assert.doesNotMatch(prompt, /undefined/);
+    guardTool(f.project, repairCall(f, run, "code-only", "Edit", { file_path: target }));
+    f.write(target, "// SYNTHETIC compile-error correction without an available Editor\n");
+    f.write(request.handoffPaths[0], "NCCGS-HANDOFF: COMPLETE\nSYNTHETIC code fix; coordinator checks pending");
+    const observed = observe(f.project, f.result(run), "agent_result");
+    assert.equal(f.state().reservations.at(-1).status, "completed");
+    assert.equal(f.state().reservations.at(-1).editorSteps, undefined);
+    recordStandalone(f.project, f.task(), "implementation", f.stage(run, observed));
+    assert.ok(f.task().history.some(h => h.stages?.review?.verdict === "CHANGES_REQUIRED"));
+    assert.equal(f.task().reviewBudget.used, 1);
+  } finally { f.dispose(); }
+});
+
 test("repair refuses missing, stale, broad and malformed packets before spending quota", () => {
   const f = fixture();
   try {
@@ -560,7 +1032,7 @@ test("native completion ignores quoted model prose and fails closed on unsupport
   }
 });
 
-function prepareStructuredReview(f, values = {}, body = null) {
+function prepareStructuredReview(f, values = {}, body = null, beforeCompletion = null) {
   const author = f.dispatch({ agent: "nccgs-game-designer" }); f.start(author);
   f.write(f.analysis, "Synthetic analysis; no game or provider acceptance.");
   const authorRuntime = observe(f.project, f.result(author), "agent_result");
@@ -572,6 +1044,7 @@ function prepareStructuredReview(f, values = {}, body = null) {
   const result = { schemaVersion: 1, taskId: task.id, contractHash: task.contractHash, snapshot: snapshot(f.project, task).sha256,
     verdict: "PASS", criteriaMet: true, findings: [], conditions: [], ...values };
   f.write(reviewPath, body ?? `NCCGS-HANDOFF: COMPLETE\n\n\`\`\`nccgs-review\n${JSON.stringify(result)}\n\`\`\`\n`);
+  beforeCompletion?.(reviewer, result, reviewPath);
   const observed = observe(f.project, f.result(reviewer), "agent_result");
   return { ...f.stage(reviewer, observed), evidence: artifact(f.project, reviewPath), verdict: result.verdict,
     criteriaMet: result.criteriaMet, findings: result.findings, conditions: result.conditions };
@@ -591,6 +1064,101 @@ test("review conditions are pinned to the reviewer and cannot be removed by coor
   } finally { f.dispose(); }
 });
 
+test("dispatch preparation produces bounded PARTIAL drafts without changing task, ledger or files", () => {
+  const f = fixture(); try {
+    const handoffPath = ".nccgs/evidence/analysis/worker handoff.md";
+    const worker = f.dispatch({ handoffPaths: [handoffPath] });
+    const before = JSON.stringify({ task: f.task(), state: f.state() });
+    const prepared = taskRun(["dispatch-prompt", "--project", f.project, "--id", "synthetic", "--dispatch", worker.reservation.id]);
+    assert.ok(prepared.prompt.startsWith(`[NCCGS-DISPATCH:${worker.reservation.id}]`));
+    assert.match(prepared.prompt, /Source write ownership: \["Assets\/fixture.cs"\]/);
+    assert.match(prepared.prompt, /synthetic-check|pinned task contract/);
+    assert.match(prepared.handoffs[0].content, /^NCCGS-HANDOFF: PARTIAL/);
+    assert.equal(fs.existsSync(path.join(f.project, handoffPath)), false);
+    assert.equal(JSON.stringify({ task: f.task(), state: f.state() }), before);
+    f.write("Assets/fixture.cs", "// changed before launch");
+    assert.throws(() => taskRun(["dispatch-prompt", "--project", f.project, "--id", "synthetic", "--dispatch", worker.reservation.id]), /snapshot stale/);
+  } finally { f.dispose(); }
+});
+
+test("reviewer validates and corrects its draft before completion; coordinator imports exact pinned result", () => {
+  const f = fixture("plan", true); try {
+    const stage = prepareStructuredReview(f, { findings: [{ severity: "INFO", status: "NOTED", description: "Synthetic disclosed limitation" }] }, null,
+      (reviewer, value, file) => {
+        const args = ["handoff-validate", "--project", f.project, "--id", "synthetic", "--dispatch", reviewer.reservation.id, "--file", file];
+        const before = JSON.stringify({ task: f.task(), state: f.state() });
+        assert.throws(() => taskRun(args), /OPEN, RESOLVED or ACCEPTED/);
+        assert.equal(JSON.stringify({ task: f.task(), state: f.state() }), before);
+        value.findings[0].status = "ACCEPTED";
+        f.write(file, `NCCGS-HANDOFF: PARTIAL\n\`\`\`nccgs-review\n${JSON.stringify(value)}\n\`\`\`\n`);
+        assert.equal(taskRun(args).complete, false);
+        assert.equal(f.task().stages.review, undefined);
+        f.write(file, `NCCGS-HANDOFF: COMPLETE\n\`\`\`nccgs-review\n${JSON.stringify(value)}\n\`\`\`\n`);
+        assert.equal(taskRun(args).complete, true);
+        const command = `node .claude/nccgs/tools/task.mjs handoff-validate --id synthetic --dispatch ${reviewer.reservation.id} --file ${file}`;
+        const envelope = { session_id: "synthetic-session", agent_id: reviewer.agentId, tool_name: "Bash", tool_input: { command } };
+        assert.doesNotThrow(() => guardTool(f.project, envelope));
+        const hook = f.hook("closure-guard.mjs", "pre", { ...envelope, hook_event_name: "PreToolUse" });
+        assert.equal(hook.status, 0, hook.stderr);
+        for (const bad of [command + " --verdict PASS", command + " --file " + file, command + " -- node evil.mjs", command + "; echo unsafe",
+          command.replace("--id synthetic", "--id other"), command.replace(file, f.analysis), command.replace("handoff-validate", "record-review"),
+          command.replace(reviewer.reservation.id, "different-dispatch")]) {
+          assert.throws(() => guardTool(f.project, { ...envelope, tool_input: { command: bad } }));
+        }
+      });
+    const bytes = fs.readFileSync(path.join(f.project, stage.evidence.path));
+    const oldTask = f.task(), oldLedger = JSON.stringify(f.state());
+    const args = ["record-review", "--project", f.project, "--id", "synthetic", "--dispatch", stage.dispatchId, "--file", stage.evidence.path];
+    const recorded = taskRun(args);
+    for (const key of ["verdict", "criteriaMet", "findings", "conditions", "runtime", "evidence", "snapshot", "dispatchId"]) assert.deepEqual(recorded.stages.review[key], stage[key]);
+    assert.equal(recorded.reviewBudget.used, oldTask.reviewBudget.used + 1);
+    assert.equal(recorded.history.length, oldTask.history.length + 1);
+    assert.deepEqual(recorded.history.slice(0, oldTask.history.length), oldTask.history);
+    assert.equal(JSON.stringify(f.state()), oldLedger);
+    assert.deepEqual(fs.readFileSync(path.join(f.project, stage.evidence.path)), bytes);
+    assert.equal(recorded.closed, undefined);
+    const saved = JSON.stringify(f.task());
+    assert.throws(() => taskRun(args), /only once/);
+    assert.equal(JSON.stringify(f.task()), saved);
+    assert.throws(() => taskRun([...args, "--verdict", "PASS"]), /unique/);
+    assert.throws(() => taskRun([...args, "--dispatch", stage.dispatchId]), /unique/);
+  } finally { f.dispose(); }
+});
+
+test("automatic review import preserves negative verdicts and mandatory manual acceptance", () => {
+  for (const verdict of ["BLOCKED", "CHANGES_REQUIRED", "PASS"]) {
+    const f = fixture("plan", true, { manualGates: ["OWNER-01"] }); try {
+      const stage = prepareStructuredReview(f, { verdict, criteriaMet: verdict === "PASS",
+        conditions: verdict === "PASS" ? [] : [{ id: "C1", description: "Required investigation remains" }] });
+      const recorded = taskRun(["record-review", "--project", f.project, "--id", "synthetic", "--dispatch", stage.dispatchId, "--file", stage.evidence.path]);
+      assert.equal(recorded.stages.review.verdict, verdict);
+      assert.deepEqual(recorded.stages.review.conditions, stage.conditions);
+      if (verdict === "PASS") {
+        recordStandalone(f.project, f.task(), "report", { outcome: "success", summary: "Synthetic technical result; owner decision still pending" });
+        assert.throws(() => taskRun(["close", "--project", f.project, "--id", "synthetic"]), /acceptance: missing/);
+      } else assert.throws(() => recordStandalone(f.project, f.task(), "report", { outcome: "success", summary: "Cannot invent success" }), /review has not passed/);
+    } finally { f.dispose(); }
+  }
+});
+
+test("automatic review import rejects tampering, conditional PASS, missing measurements and legacy policy without consuming a record", () => {
+  for (const variant of ["tampered", "source", "conditional", "unmeasured", "legacy", "unattached", "incomplete", "malformed"]) {
+    const f = fixture("plan", variant !== "legacy", variant === "unmeasured" ? { acceptance: [{ id: "AC", description: "Measured result", check: "synthetic-check",
+      assertions: [{ artifact: ".nccgs/evidence/measurements/result.json", pointer: "/actual", op: "eq", value: true }] }] } : {});
+    try {
+      const stage = prepareStructuredReview(f, variant === "conditional" ? { conditions: [{ id: "C1", description: "Still needs evidence" }] } : {},
+        variant === "incomplete" ? "NCCGS-HANDOFF: PARTIAL\nNot finished" : variant === "malformed" ? "NCCGS-HANDOFF: COMPLETE\n```nccgs-review\ninvalid\n```" : null);
+      let file = stage.evidence.path;
+      if (variant === "tampered") f.write(file, fs.readFileSync(path.join(f.project, file), "utf8") + "\nEdited after completion\n");
+      if (variant === "source") f.write("Assets/fixture.cs", "// unrelated source change invalidates evidence");
+      if (variant === "unattached") { file = ".nccgs/evidence/analysis/copied.md"; f.write(file, fs.readFileSync(path.join(f.project, stage.evidence.path), "utf8")); }
+      const before = JSON.stringify({ task: f.task(), state: f.state() });
+      assert.throws(() => taskRun(["record-review", "--project", f.project, "--id", "synthetic", "--dispatch", stage.dispatchId, "--file", file]));
+      assert.equal(JSON.stringify({ task: f.task(), state: f.state() }), before);
+    } finally { f.dispose(); }
+  }
+});
+
 test("complete negative review retains pending conditions; complete unconditional review may close", () => {
   for (const verdict of ["BLOCKED", "PASS"]) {
     const f = fixture("plan", true); try {