nccgs 1.3.0 → 2.0.0-rc.2

package/tests/phase1.test.mjs

@@ -0,0 +1,324 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+import { atomicJson, json } from "../.claude/nccgs/tools/policy.mjs";
+import { initialize } from "../.claude/nccgs/tools/gates.mjs";
+import { acquireLock, delay, pidState, treeState } from "../.claude/nccgs/tools/process-lock.mjs";
+import { startCommand } from "../.claude/nccgs/tools/command-process.mjs";
+import { startVerification, waitVerification, jobStatus, readJob, jobDirectory } from "../.claude/nccgs/tools/verification-jobs.mjs";
+import { safeVerifyCommand, guardTool } from "../.claude/nccgs/tools/tool-guard.mjs";
+import { cumulativeCost, supervise } from "../scripts/supervise.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+function fixture(timeoutMs = 5000, mode = "implement") {
+  const base = fs.realpathSync(os.tmpdir()), project = fs.mkdtempSync(path.join(base, "nccgs-phase1-"));
+  const write = (relative, value) => {
+    const file = path.join(project, relative); fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, typeof value === "string" ? value : JSON.stringify(value)); return file;
+  };
+  fs.cpSync(path.join(root, ".claude/nccgs/tools"), path.join(project, ".claude/nccgs/tools"), { recursive: true });
+  for (const file of ["pipeline.json", "studio.json"]) write(`.claude/nccgs/${file}`, fs.readFileSync(path.join(root, ".claude/nccgs", file), "utf8"));
+  write("Assets/source.cs", "// frozen fixture source");
+  write(".nccgs/project.yaml", "schema_version: 2\nmodels:\n  profile: claude-standalone\n");
+  write(".nccgs/execution.json", { schemaVersion: 1, name: "standalone", externalReview: { mode: "off" } });
+  write(".nccgs/inputs.json", { schemaVersion: 1, canonicalInputs: [], outputDirectories: [], checks: { test: { timeoutMs } } });
+  write(".nccgs/intake.json", { objective: "Process lifecycle fixture; no actual Claude/model/game execution", mode, requiredChecks: ["test"] });
+  initialize(project, "fixture", null, null, null, { intake: ".nccgs/intake.json" });
+  const env = { ...process.env };
+  for (const key of ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT", "NCCGS_TASK_ID", "NCCGS_SUPERVISED_SESSION", "NCCGS_PROJECT_ROOT"]) delete env[key];
+  const cli = (...args) => spawnSync(process.execPath, [path.join(project, ".claude/nccgs/tools/task.mjs"), ...args, "--project", project], { cwd: project, env, encoding: "utf8", timeout: 20000, windowsHide: true });
+  return { project, write, env, cli, dispose() {
+    assert.equal(path.dirname(fs.realpathSync(project)).toLowerCase(), base.toLowerCase());
+    assert.ok(path.basename(project).startsWith("nccgs-phase1-"));
+    fs.rmSync(project, { recursive: true, force: true });
+  } };
+}
+
+test("verify parser separates helper options from the framework root and rejects shell composition", () => {
+  const f = fixture();
+  try {
+    const prefix = `node "${f.project.replaceAll("\\", "/")}/.claude/nccgs/tools/task.mjs" verify --id fixture --name test --project "${f.project}"`;
+    assert.equal(safeVerifyCommand(`${prefix} -- node helper.mjs --project "${f.project}"`, f.project), true);
+    assert.equal(safeVerifyCommand(`${prefix} -- node helper.mjs --project=anything`, f.project), true);
+    assert.equal(safeVerifyCommand(`${prefix} -- node -e "console.log('a;b')"`, f.project), true);
+    assert.equal(safeVerifyCommand(`${prefix} --project other -- node x`, f.project), false);
+    assert.equal(safeVerifyCommand(`${prefix.replace(`--project "${f.project}"`, '--project "../foreign"')} -- node x`, f.project), false);
+    for (const suffix of ["; echo bad", " && echo bad", " > output", " | node x"]) assert.equal(safeVerifyCommand(`${prefix} -- node x${suffix}`, f.project), false);
+    assert.equal(safeVerifyCommand(`${prefix} -- node -e "$(touch bad)"`, f.project), false);
+    f.write(".nccgs/runtime/bindings/parser.json", { taskId: "fixture" });
+    assert.doesNotThrow(() => guardTool(f.project, { session_id: "parser", tool_name: "Bash", tool_input: { command: `${prefix} -- node helper.mjs --project "${f.project}"` } }));
+  } finally { f.dispose(); }
+});
+
+test("detached verification survives its caller and repeated request keys reuse one immutable receipt", () => {
+  const f = fixture();
+  try {
+    const code = "setTimeout(()=>{require('node:fs').appendFileSync('.nccgs/evidence/count.txt','run\\n');console.log('real subprocess output')},400)";
+    const args = ["verify", "--id", "fixture", "--name", "test", "--background", "--request-key", "once", "--", process.execPath, "-e", code];
+    // Add the framework project before the separator, as real callers must do.
+    const first = spawnSync(process.execPath, [path.join(f.project, ".claude/nccgs/tools/task.mjs"), ...args], { cwd: f.project, env: f.env, encoding: "utf8", windowsHide: true });
+    assert.equal(first.status, 0, first.stderr); const started = JSON.parse(first.stdout);
+    const result = waitVerification(f.project, started.jobId, "fixture", 10000);
+    assert.equal(result.status, "PASS");
+    const duplicate = startVerification(f.project, "fixture", { name: "test", executable: process.execPath, arguments: ["-e", code], requestKey: "once" });
+    assert.deepEqual(duplicate.evidence, result.evidence);
+    assert.equal(fs.readFileSync(path.join(f.project, ".nccgs/evidence/count.txt"), "utf8"), "run\n");
+    const receipt = json(path.join(f.project, result.evidence.path));
+    assert.equal(receipt.sourceUnchanged, true); assert.equal(receipt.exitCode, 0);
+    f.write("Assets/source.cs", "// changed");
+    assert.throws(() => startVerification(f.project, "fixture", { name: "test", executable: process.execPath, arguments: ["-e", code], requestKey: "once" }), /changed source/);
+    assert.throws(() => jobStatus(f.project, started.jobId, "other"), /another task/);
+  } finally { f.dispose(); }
+});
+
+test("timeout and source mutation produce failed receipts, never reusable PASS", () => {
+  const f = fixture(200);
+  try {
+    const timed = startVerification(f.project, "fixture", { name: "test", executable: process.execPath, arguments: ["-e", "setTimeout(()=>{},10000)"], requestKey: "timeout" });
+    const failure = waitVerification(f.project, timed.jobId, "fixture", 15000);
+    assert.equal(failure.status, "FAIL"); assert.equal(json(path.join(f.project, failure.evidence.path)).timedOut, true);
+  } finally { f.dispose(); }
+  // A mutation needs time to execute; the timeout probe's 200ms budget could kill
+  // Node startup first under concurrent Windows tests and never touch the source.
+  const mutationFixture = fixture(5000);
+  try {
+    const changed = startVerification(mutationFixture.project, "fixture", { name: "test", executable: process.execPath, arguments: ["-e", "require('node:fs').writeFileSync('Assets/source.cs','changed')"], requestKey: "mutation" });
+    const mutation = waitVerification(mutationFixture.project, changed.jobId, "fixture", 10000);
+    const receipt = json(path.join(mutationFixture.project, mutation.evidence.path));
+    assert.equal(mutation.status, "FAIL"); assert.equal(receipt.sourceUnchanged, false);
+    assert.equal(receipt.timedOut, false);
+  } finally { mutationFixture.dispose(); }
+});
+
+test("per-attempt timeout is bounded, pinned and forwarded only before the helper separator", () => {
+  const f = fixture();
+  try {
+    const beforeInputs = fs.readFileSync(path.join(f.project, ".nccgs/inputs.json"), "utf8");
+    const command = [process.execPath, "-e", "console.log('bounded timeout fixture')"];
+    const invoke = extra => spawnSync(process.execPath, [path.join(f.project, ".claude/nccgs/tools/task.mjs"),
+      "verify", "--id", "fixture", "--name", "long-check", "--request-key", "long-once", ...extra, "--", ...command],
+      { cwd: f.project, env: f.env, encoding: "utf8", windowsHide: true, timeout: 20000 });
+    const first = invoke(["--timeout-ms", "900000"]);
+    assert.equal(first.status, 0, first.stderr);
+    const result = JSON.parse(first.stdout);
+    assert.equal(result.status, "PASS");
+    assert.equal(json(path.join(f.project, result.evidence.path)).timeoutMs, 900000);
+    assert.equal(readJob(f.project, result.jobId).timeoutMs, 900000);
+    const duplicate = invoke(["--timeout-ms", "900000"]);
+    assert.equal(duplicate.status, 0, duplicate.stderr);
+    assert.deepEqual(JSON.parse(duplicate.stdout).evidence, result.evidence);
+    assert.notEqual(invoke(["--timeout-ms", "800000"]).status, 0);
+    assert.equal(fs.readFileSync(path.join(f.project, ".nccgs/inputs.json"), "utf8"), beforeInputs);
+    for (const timeoutMs of [0, 99, 1.5, 7200001, NaN, Infinity, null, "900000"]) {
+      assert.throws(() => startVerification(f.project, "fixture", { name: "long-check", executable: process.execPath,
+        arguments: command.slice(1), requestKey: "invalid", timeoutMs }), /timeoutMs/);
+    }
+    assert.throws(() => startVerification(f.project, "fixture", { name: "test", executable: process.execPath,
+      arguments: command.slice(1), requestKey: "configured-limit", timeoutMs: 5001 }), /configured check timeout/);
+    const helper = f.write(".nccgs/helper.mjs", "console.log(process.argv.slice(2).join(' '));");
+    const forwarded = spawnSync(process.execPath, [path.join(f.project, ".claude/nccgs/tools/task.mjs"),
+      "verify", "--id", "fixture", "--name", "test", "--request-key", "helper-timeout", "--", process.execPath, helper,
+      "--timeout-ms", "900000"], { cwd: f.project, env: f.env, encoding: "utf8", windowsHide: true, timeout: 20000 });
+    assert.equal(forwarded.status, 0, forwarded.stderr);
+    const forwardedReceipt = json(path.join(f.project, JSON.parse(forwarded.stdout).evidence.path));
+    assert.equal(forwardedReceipt.timeoutMs, 5000);
+    assert.match(fs.readFileSync(path.join(f.project, forwardedReceipt.log.path), "utf8"), /--timeout-ms 900000/);
+  } finally { f.dispose(); }
+});
+
+test("long verification remains owned and bounded by its pinned supervisor deadline", () => {
+  const f = fixture();
+  try {
+    const runId = crypto.randomUUID(), sessionId = crypto.randomUUID(), deadline = Date.now() + 2500;
+    f.write(`.nccgs/runs/task-fixture.lock`, { runId });
+    const run = { project: f.project, taskId: "fixture", sessionId, deadline };
+    f.write(`.nccgs/runs/${runId}/run.json`, run);
+    const args = [path.join(f.project, ".claude/nccgs/tools/task.mjs"), "verify", "--id", "fixture",
+      "--name", "long-check", "--request-key", "supervised-long", "--timeout-ms", "900000", "--",
+      process.execPath, "-e", "setTimeout(()=>{require('node:fs').writeFileSync('.nccgs/evidence/late.txt','bad')},60000)"];
+    const env = { ...f.env, NCCGS_SUPERVISED_SESSION: sessionId };
+    const result = spawnSync(process.execPath, args, { cwd: f.project, env, encoding: "utf8", windowsHide: true, timeout: 20000 });
+    assert.equal(result.status, 1, result.stderr);
+    const stopped = JSON.parse(result.stdout), receipt = json(path.join(f.project, stopped.evidence.path));
+    assert.equal(receipt.status, "FAIL"); assert.equal(receipt.timedOut, true);
+    assert.equal(receipt.timeoutMs, 900000); assert.equal(receipt.supervisorDeadline, deadline);
+    const launch = json(path.join(jobDirectory(f.project, stopped.jobId), "launch.json"));
+    assert.equal(pidState(launch.pid), "dead");
+    assert.equal(fs.existsSync(path.join(f.project, ".nccgs/evidence/late.txt")), false);
+    // A settled request remains idempotent after expiry; a fresh attempt cannot run.
+    const repeat = spawnSync(process.execPath, args, { cwd: f.project, env, encoding: "utf8", windowsHide: true, timeout: 10000 });
+    assert.deepEqual(JSON.parse(repeat.stdout).evidence, stopped.evidence);
+    const freshArgs = args.map(a => a === "supervised-long" ? "too-late" : a);
+    const expired = spawnSync(process.execPath, freshArgs, { cwd: f.project, env, encoding: "utf8", windowsHide: true, timeout: 10000 });
+    assert.notEqual(expired.status, 0); assert.match(expired.stderr, /deadline reached/);
+    const foreign = spawnSync(process.execPath, freshArgs, { cwd: f.project, env: { ...env, NCCGS_SUPERVISED_SESSION: crypto.randomUUID() }, encoding: "utf8", windowsHide: true, timeout: 10000 });
+    assert.notEqual(foreign.status, 0); assert.match(foreign.stderr, /binding mismatch/);
+  } finally { f.dispose(); }
+});
+
+test("dead lock owners recover with evidence; live, unknown, legacy and spawning owners do not expire", () => {
+  const f = fixture();
+  try {
+    const file = path.join(f.project, ".nccgs/test.lock");
+    const module = new URL("../.claude/nccgs/tools/process-lock.mjs", import.meta.url).href;
+    const held = spawnSync(process.execPath, ["--input-type=module", "-e", `import {acquireLock} from ${JSON.stringify(module)}; acquireLock(${JSON.stringify(file)});`], { encoding: "utf8", windowsHide: true });
+    assert.equal(held.status, 0, held.stderr);
+    const recovered = acquireLock(file);
+    assert.ok(fs.existsSync(`${file}.recoveries.jsonl`));
+    assert.throws(() => acquireLock(file), /live or unverified/); recovered.release();
+    for (const owner of [{ pid: 99999999 }, { schemaVersion: 1, host: "other-machine", pid: 99999999, token: "remote" },
+      { schemaVersion: 1, host: os.hostname(), pid: 99999999, token: "gap", phase: "spawning" }]) {
+      atomicJson(file, owner); assert.throws(() => acquireLock(file), /live or unverified/); fs.unlinkSync(file);
+    }
+  } finally { f.dispose(); }
+});
+
+test("a dead owner with a live command retains its engine lock", async () => {
+  const f = fixture(), child = spawn(process.execPath, ["-e", "setTimeout(()=>{},20000)"], { stdio: "ignore", windowsHide: true });
+  try {
+    await new Promise((resolve, reject) => { child.once("spawn", resolve); child.once("error", reject); });
+    const file = path.join(f.project, ".nccgs/engine.lock");
+    atomicJson(file, { schemaVersion: 1, host: os.hostname(), pid: 99999999, token: "dead-parent", phase: "running", child: { pid: child.pid, group: false } });
+    assert.throws(() => acquireLock(file), /live or unverified/);
+    const closed = new Promise(resolve => child.once("close", resolve)); child.kill(); await closed;
+    // Legacy/unmanaged children cannot prove that descendants have exited.
+    if (process.platform === "win32") assert.throws(() => acquireLock(file), /live or unverified/);
+  } finally { if (pidState(child.pid) === "alive") child.kill(); f.dispose(); }
+});
+
+test("OS-owned process group retains orphan descendants and proves their exit after host termination", { skip: process.platform !== "win32" }, async () => {
+  const f = fixture(); let host, descendant;
+  try {
+    const id = crypto.randomUUID(), directory = path.join(f.project, ".nccgs");
+    const code = "const cp=require('node:child_process'),fs=require('node:fs');const p=cp.spawn(process.execPath,['-e','setTimeout(()=>{},20000)'],{stdio:'ignore',detached:true});fs.writeFileSync('.nccgs/descendant.json',JSON.stringify({pid:p.pid}));p.unref();";
+    const managed = startCommand({ executable: process.execPath, args: ["-e", code], cwd: f.project, stateDirectory: directory, id, stdio: "ignore" });
+    host = managed.child;
+    const closed = new Promise(resolve => host.once("close", resolve));
+    const deadline = Date.now() + 10000;
+    while (!fs.existsSync(path.join(directory, "descendant.json")) && Date.now() < deadline) await delay(50);
+    descendant = json(path.join(directory, "descendant.json")).pid;
+    assert.equal(pidState(descendant), "alive"); assert.equal(pidState(host.pid), "alive");
+    const file = path.join(directory, "engine.lock");
+    atomicJson(file, { schemaVersion: 1, host: os.hostname(), pid: 99999999, token: "orphan-owner", phase: "running", child: managed.identity() });
+    assert.throws(() => acquireLock(file), /live or unverified/);
+    host.kill("SIGKILL"); await closed;
+    assert.equal(treeState(managed.identity()), "dead"); assert.equal(pidState(descendant), "dead");
+    const recovered = acquireLock(file); recovered.release();
+    assert.ok(fs.existsSync(`${file}.recoveries.jsonl`));
+  } finally { if (host && pidState(host.pid) === "alive") host.kill("SIGKILL"); f.dispose(); }
+});
+
+test("orphan verification becomes a retained failed attempt without rerunning the command", () => {
+  const f = fixture();
+  try {
+    const jobId = crypto.randomUUID(), directory = jobDirectory(f.project, jobId);
+    fs.mkdirSync(directory, { recursive: true });
+    atomicJson(path.join(directory, "request.json"), { schemaVersion: 1, id: jobId, project: fs.realpathSync(f.project), taskId: "fixture", name: "test", queuedAt: new Date().toISOString(), snapshot: "unknown", executable: "unlaunched", arguments: [] });
+    atomicJson(path.join(directory, "owner.lock"), { schemaVersion: 1, host: os.hostname(), pid: 99999999, token: "orphan", phase: "owned", child: null });
+    const failed = jobStatus(f.project, jobId, "fixture");
+    assert.equal(failed.status, "FAIL");
+    assert.equal(json(path.join(f.project, failed.evidence.path)).exitCode, null);
+    assert.match(json(path.join(f.project, failed.evidence.path)).error, /without a terminal receipt/);
+    assert.deepEqual(jobStatus(f.project, jobId, "fixture").evidence, failed.evidence);
+  } finally { f.dispose(); }
+});
+
+// The fake native executable below is explicitly a fixture, never Claude evidence.
+function fakeNative(f, { missingUsage = false, omitReport = false } = {}) {
+  return f.write(".nccgs/fake-native.mjs", `
+import fs from 'node:fs';
+import {run} from '../.claude/nccgs/tools/task.mjs';
+const args=process.argv.slice(2), resumed=args.includes('--resume');
+const session=args[args.indexOf(resumed?'--resume':'--session-id')+1];
+if(!resumed) run(['verify','--id','fixture','--name','test','--background','--request-key','native-once','--',process.execPath,'-e',"setTimeout(()=>console.log('fixture command done'),800)"]);
+else if(${!omitReport}) run(['report','--id','fixture','--outcome','partial','--summary','Fixture native continuation read the managed receipt; no game acceptance']);
+console.log(JSON.stringify({type:'result',session_id:session,total_cost_usd:${missingUsage ? "null" : "resumed?0.6:0.4"},result:'Synthetic native result; no actual model execution'}));
+`);
+}
+test("supervisor waits outside the model, resumes the same session once, preserves cumulative budget and receipts", async () => {
+  const f = fixture();
+  try {
+    const binary = fakeNative(f), prompt = f.write(".nccgs/prompt.txt", "Fixture only");
+    const plan = { project: f.project, binary: process.execPath, mode: "full", args: [binary], env: f.env,
+      supervision: { taskId: "fixture", promptFile: prompt, budgetUsd: 1, maxResumes: 1, timeoutMs: 20000 } };
+    assert.equal(await supervise(plan), 0);
+    const runId = fs.readdirSync(path.join(f.project, ".nccgs/runs"), { withFileTypes: true }).find(e => e.isDirectory()).name;
+    const state = json(path.join(f.project, `.nccgs/runs/${runId}/run.json`));
+    assert.equal(state.status, "settled"); assert.equal(state.invocations.length, 2);
+    assert.equal(state.cumulativeCostUsd, 0.6); assert.equal(state.invocations[1].allowanceUsd, 0.6);
+    assert.equal(state.invocations[0].terminal.session_id, state.invocations[1].terminal.session_id);
+    assert.equal(fs.readdirSync(path.join(f.project, ".nccgs/jobs")).length, 1);
+    assert.equal(await supervise({ ...plan, supervision: { recoverRun: runId } }), 0);
+    assert.equal(json(path.join(f.project, `.nccgs/runs/${runId}/run.json`)).invocations.length, 2);
+  } finally { f.dispose(); }
+});
+
+test("supervisor can settle a plan without granting source writes or shell checks", async () => {
+  const f = fixture(5000, "plan");
+  try {
+    const binary = f.write(".nccgs/plan-native.mjs", `import {run} from '../.claude/nccgs/tools/task.mjs';
+const args=process.argv.slice(2);const session=args[args.indexOf('--session-id')+1];
+run(['report','--id','fixture','--outcome','partial','--summary','Synthetic plan report; document review pending']);
+console.log(JSON.stringify({type:'result',session_id:session,total_cost_usd:0.1,result:'Synthetic, not real Claude'}));`);
+    const prompt = f.write(".nccgs/prompt.txt", "Synthetic plan supervision");
+    assert.equal(await supervise({ project: f.project, binary: process.execPath, mode: "full", args: [binary], env: f.env,
+      supervision: { taskId: "fixture", promptFile: prompt, budgetUsd: 1, maxResumes: 0, timeoutMs: 20000 } }), 0);
+    const runId = fs.readdirSync(path.join(f.project, ".nccgs/runs"), { withFileTypes: true }).find(e => e.isDirectory()).name;
+    const state = json(path.join(f.project, `.nccgs/runs/${runId}/run.json`));
+    assert.equal(state.status, "settled"); assert.equal(state.invocations.length, 1);
+    assert.throws(() => guardTool(f.project, { session_id: state.sessionId, tool_name: "Write", tool_input: { file_path: "Assets/source.cs" } }), /cannot edit source/);
+    assert.throws(() => guardTool(f.project, { session_id: state.sessionId, tool_name: "Bash", tool_input: { command: "node helper.mjs" } }), /shell execution is blocked/);
+  } finally { f.dispose(); }
+});
+
+test("supervisor retains unknown usage and refuses a renewed budget", async () => {
+  const f = fixture();
+  try {
+    const binary = fakeNative(f, { missingUsage: true }), prompt = f.write(".nccgs/prompt.txt", "Fixture only");
+    assert.equal(await supervise({ project: f.project, binary: process.execPath, mode: "full", args: [binary], env: f.env,
+      supervision: { taskId: "fixture", promptFile: prompt, budgetUsd: 1, maxResumes: 2, timeoutMs: 20000 } }), 1);
+    const runId = fs.readdirSync(path.join(f.project, ".nccgs/runs"), { withFileTypes: true }).find(e => e.isDirectory()).name;
+    const state = json(path.join(f.project, `.nccgs/runs/${runId}/run.json`));
+    assert.equal(state.status, "blocked"); assert.equal(state.invocations.length, 1); assert.match(state.reason, /cost/);
+    const jobId = fs.readdirSync(path.join(f.project, ".nccgs/jobs"))[0];
+    const verified = waitVerification(f.project, jobId, "fixture", 10000);
+    assert.equal(verified.status, "PASS", JSON.stringify(verified.evidence ? json(path.join(f.project, verified.evidence.path)) : verified));
+  } finally { f.dispose(); }
+});
+
+test("cumulative native cost rejects double counting, missing and mismatched sessions", () => {
+  assert.equal(cumulativeCost(0.4, { type: "result", session_id: "s", total_cost_usd: 0.6 }, "s"), 0.6);
+  assert.throws(() => cumulativeCost(0.4, { type: "result", session_id: "s", total_cost_usd: 0.2 }, "s"), /decreasing/);
+  assert.throws(() => cumulativeCost(0, { type: "result", session_id: "wrong", total_cost_usd: 0.2 }, "s"), /correlated/);
+});
+
+test("supervisor stops at the pinned continuation limit without resetting the attempt", async () => {
+  const f = fixture();
+  try {
+    const executable = fakeNative(f, { omitReport: true }), prompt = f.write(".nccgs/prompt.txt", "Fixture only");
+    assert.equal(await supervise({ project: f.project, binary: process.execPath, mode: "full", args: [executable], env: f.env,
+      supervision: { taskId: "fixture", promptFile: prompt, budgetUsd: 1, maxResumes: 1, timeoutMs: 20000 } }), 1);
+    const runId = fs.readdirSync(path.join(f.project, ".nccgs/runs"), { withFileTypes: true }).find(e => e.isDirectory()).name;
+    const state = json(path.join(f.project, `.nccgs/runs/${runId}/run.json`));
+    assert.equal(state.invocations.length, 2); assert.match(state.reason, /Continuation limit/);
+    assert.equal(state.cumulativeCostUsd, 0.6); assert.ok(state.checkpoint);
+  } finally { f.dispose(); }
+});
+
+test("supervisor refuses a fresh native invocation after the session allowance is spent", async () => {
+  const f = fixture();
+  try {
+    const executable = fakeNative(f), prompt = f.write(".nccgs/prompt.txt", "Fixture only");
+    assert.equal(await supervise({ project: f.project, binary: process.execPath, mode: "full", args: [executable], env: f.env,
+      supervision: { taskId: "fixture", promptFile: prompt, budgetUsd: 0.4, maxResumes: 2, timeoutMs: 20000 } }), 1);
+    const runId = fs.readdirSync(path.join(f.project, ".nccgs/runs"), { withFileTypes: true }).find(e => e.isDirectory()).name;
+    const state = json(path.join(f.project, `.nccgs/runs/${runId}/run.json`));
+    assert.equal(state.invocations.length, 1); assert.equal(state.cumulativeCostUsd, 0.4);
+    assert.match(state.reason, /budget exhausted/); assert.equal(state.costCoverage, "complete");
+  } finally { f.dispose(); }
+});

package/tests/phase2.test.mjs

@@ -0,0 +1,250 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+import { artifact, json } from "../.claude/nccgs/tools/policy.mjs";
+import { initialize, snapshot, record, close, taskPath, refreshInputs, reclassify } from "../.claude/nccgs/tools/gates.mjs";
+import { reserve, claim, attachAgent, complete, status, reconcile } from "../.claude/nccgs/tools/orchestration.mjs";
+import { startVerification, waitVerification } from "../.claude/nccgs/tools/verification-jobs.mjs";
+import { assessCriteria } from "../.claude/nccgs/tools/criteria.mjs";
+import { guardTool, safeTaskCommand } from "../.claude/nccgs/tools/tool-guard.mjs";
+import { run } from "../.claude/nccgs/tools/task.mjs";
+
+// Provider observations in these tests are SYNTHETIC fixtures, never Claude evidence.
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const measurement = ".nccgs/evidence/measurements/runtime.json";
+const criteria = ["needle", "orbit"].map(id => ({ id, description: `${id} wins unassisted`, check: "runtime", checkpoint: "early",
+  assertions: [{ artifact: measurement, pointer: `/builds/${id}/won`, op: "eq", value: true },
+    { artifact: measurement, pointer: "/assisted", op: "eq", value: false },
+    { artifact: measurement, pointer: "/reportOnly", op: "eq", value: false }] }));
+const passed = { builds: { needle: { won: true }, orbit: { won: true } }, assisted: false, reportOnly: false };
+
+function fixture(acceptance = criteria, contractOverrides = {}) {
+  const temporaryRoot = fs.realpathSync(os.tmpdir()), project = fs.mkdtempSync(path.join(temporaryRoot, "nccgs-phase2-"));
+  const write = (relative, value) => {
+    const file = path.join(project, relative); fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, typeof value === "string" ? value : JSON.stringify(value)); return artifact(project, relative);
+  };
+  fs.cpSync(path.join(root, ".claude/nccgs/tools"), path.join(project, ".claude/nccgs/tools"), { recursive: true });
+  for (const file of ["pipeline.json", "studio.json"]) write(`.claude/nccgs/${file}`, fs.readFileSync(path.join(root, ".claude/nccgs", file), "utf8"));
+  write("Assets/game.cs", "// fixture baseline");
+  write("Tools/probe.mjs", `import fs from 'node:fs';fs.mkdirSync('.nccgs/evidence/measurements',{recursive:true});const input=JSON.parse(process.argv[2]);if(input.delayMs)await new Promise(r=>setTimeout(r,input.delayMs));if(!input.skip)fs.writeFileSync('${measurement}',input.malformed?'bad JSON':JSON.stringify(input.data));console.log('Synthetic gameplay measurement fixture');process.exitCode=input.exitCode||0;`);
+  write(".nccgs/project.yaml", "schema_version: 2\nmodels:\n  profile: claude-standalone\n");
+  write(".nccgs/execution.json", { schemaVersion: 1, name: "standalone", externalReview: { mode: "off" } });
+  write(".nccgs/inputs.json", { schemaVersion: 1, canonicalInputs: [], outputDirectories: [], checks: { runtime: { timeoutMs: 15000 } } });
+  const intake = { objective: "Synthetic test of acceptance mapping and repair budget", mode: "implement", readiness: "ready", requiredChecks: ["runtime"], acceptance, ...contractOverrides };
+  write(".nccgs/intake.json", intake);
+  initialize(project, "fixture", null, null, null, { intake: ".nccgs/intake.json" });
+  let serial = 0;
+  const task = () => json(taskPath(project, "fixture"));
+  const snap = () => snapshot(project, task()).sha256;
+  const assess = () => assessCriteria(project, task(), snap());
+  function verify(data = passed, options = {}) {
+    const job = startVerification(project, "fixture", { name: "runtime", executable: process.execPath, arguments: ["Tools/probe.mjs", JSON.stringify({ data, ...options })], requestKey: `probe-${++serial}` });
+    return waitVerification(project, job.jobId, "fixture", 20000);
+  }
+  function request(kind = "implementation", overrides = {}) {
+    return { kind, agent: kind === "review" ? "nccgs-adversarial-reviewer" : kind === "analysis" ? "nccgs-qa-engineer" : "nccgs-gameplay-programmer",
+      requestKey: `dispatch-${++serial}`, reason: "SYNTHETIC TEST FIXTURE", writePaths: kind === "implementation" ? ["Assets/game.cs"] : [], ...overrides };
+  }
+  function worker(kind = "implementation", overrides = {}, mutate = null) {
+    const req = request(kind, overrides);
+    if (req.purpose === "repair") {
+      req.workPacket = `.nccgs/evidence/work-packets/${req.requestKey}.json`;
+      req.handoffPaths = [`.nccgs/evidence/analysis/${req.requestKey}.md`];
+      write(req.workPacket, { schemaVersion: 1, taskId: "fixture", contractHash: task().contractHash, sourceSnapshot: snap(),
+        problem: "Synthetic acceptance failure", solution: "Apply the predetermined fixture correction", changes: [{ path: "Assets/game.cs", instruction: "Apply the synthetic bounded correction" }],
+        context: [], verification: ["runtime"] });
+    }
+    const d = reserve(project, "fixture", req), count = ++serial;
+    claim(project, d.id, { sessionId: "fixture-session", toolUseId: `tool-${count}`, agent: req.agent });
+    if (req.workPacket) {
+      attachAgent(project, d.id, `${kind}-${count}`);
+      guardTool(project, { session_id: "fixture-session", agent_id: `${kind}-${count}`, tool_use_id: `edit-${count}`, tool_name: "Edit", tool_input: { file_path: "Assets/game.cs", old_string: "fixture", new_string: "correction" } });
+    }
+    if (mutate) mutate();
+    if (req.workPacket) {
+      const content = "NCCGS-HANDOFF: COMPLETE\nSynthetic bounded correction; coordinator verification pending.";
+      guardTool(project, { session_id: "fixture-session", agent_id: `${kind}-${count}`, tool_use_id: `handoff-${count}`, tool_name: "Write", tool_input: { file_path: req.handoffPaths[0], content } });
+      write(req.handoffPaths[0], content);
+    }
+    const current = task(), route = kind === "review" ? current.execution.profile.models.review : current.implementationRoute;
+    const source = `.nccgs/evidence/raw-${count}.json`;
+    write(source, { taskId: "fixture", contractHash: current.contractHash, snapshot: snap(), dispatchId: d.id,
+      sessionId: "fixture-session", toolUseId: `tool-${count}`, agentId: `${kind}-${count}`, status: "completed", capturedAt: new Date().toISOString(),
+      observedProvider: "claude-code", observedModel: route.model === "sonnet" ? "claude-sonnet-4-6" : "claude-opus-5-5", observedEffort: null,
+      provenance: { kind: "provider-log", reference: "SYNTHETIC TEST FIXTURE, not real Claude" } });
+    const runtime = run(["observe", "--project", project, "--id", "fixture", "--file", source]);
+    complete(project, d.id, { runtime });
+    return { snapshot: snap(), dispatchId: d.id, runtime };
+  }
+  const work = (attempt, receipt) => record(project, "fixture", "implementation", { ...attempt, checks: [{ name: "runtime", status: "PASS", evidence: receipt.evidence }] });
+  const review = (attempt, verdict = "PASS") => record(project, "fixture", "review", { ...attempt, verdict, criteriaMet: verdict === "PASS", findings: [], evidence: write(`.nccgs/evidence/review-${++serial}.md`, "Synthetic independent review; never native evidence") });
+  return { project, write, intake, task, snap, assess, verify, request, worker, work, review, dispose() {
+    assert.equal(path.dirname(fs.realpathSync(project)).toLowerCase(), temporaryRoot.toLowerCase());
+    assert.ok(path.basename(project).startsWith("nccgs-phase2-")); assert.equal(fs.lstatSync(project).isSymbolicLink(), false);
+    fs.rmSync(project, { recursive: true, force: true });
+  } };
+}
+
+test("technical exit 0 cannot turn failed or assisted gameplay into acceptance PASS", () => {
+  const f = fixture();
+  try {
+    const attempt = f.worker();
+    const receipt = f.verify({ ...passed, builds: { needle: { won: false }, orbit: { won: false } }, reportOnly: true });
+    assert.equal(receipt.status, "PASS"); assert.deepEqual(f.assess().criteria.map(c => c.status), ["FAIL", "FAIL"]);
+    f.work(attempt, receipt);
+    const reviewer = f.worker("review");
+    assert.throws(() => f.review(reviewer), /Acceptance criteria not proven/);
+    f.review(reviewer, "CHANGES_REQUIRED");
+    assert.throws(() => record(f.project, "fixture", "report", { outcome: "success", summary: "Incorrect PASS" }), /Cannot report success/);
+    const partial = record(f.project, "fixture", "report", { outcome: "partial", summary: "Two unassisted builds remain unproven" });
+    assert.equal(partial.stages.report.acceptanceAssessment.status, "FAIL");
+    assert.throws(() => close(f.project, "fixture"), /review has not passed/);
+    assert.equal(f.verify({ ...passed, assisted: true }).status, "PASS");
+    assert.equal(f.assess().status, "FAIL");
+  } finally { f.dispose(); }
+});
+
+test("fresh measured criteria plus independent review permit DONE", () => {
+  const f = fixture();
+  try {
+    const attempt = f.worker(), receipt = f.verify(); f.work(attempt, receipt);
+    assert.equal(f.assess().status, "PASS"); f.review(f.worker("review"));
+    record(f.project, "fixture", "report", { outcome: "success", summary: "Synthetic acceptance passed" });
+    assert.equal(close(f.project, "fixture").phase, "DONE");
+    assert.equal(run(["acceptance-status", "--project", f.project, "--id", "fixture"]).automaticPassed, true);
+  } finally { f.dispose(); }
+});
+
+test("missing, malformed, old, failed and source-stale measurements stay unverified", () => {
+  const f = fixture();
+  try {
+    assert.equal(f.assess().status, "UNVERIFIED");
+    f.write(measurement, passed); f.verify(passed, { skip: true });
+    assert.equal(f.assess().status, "UNVERIFIED");
+    f.verify(passed, { malformed: true }); assert.equal(f.assess().status, "UNVERIFIED");
+    f.verify({ ...passed, builds: {} }); assert.equal(f.assess().status, "UNVERIFIED");
+    f.verify(); assert.equal(f.assess().status, "PASS");
+    assert.equal(f.verify(passed, { exitCode: 2 }).status, "FAIL"); assert.equal(f.assess().status, "UNVERIFIED");
+    f.verify(); f.write("Assets/game.cs", "// changed after verification"); assert.equal(f.assess().status, "UNVERIFIED");
+  } finally { f.dispose(); }
+});
+
+test("frozen measurement survives output overwrite but detects captured-evidence tampering", () => {
+  const f = fixture();
+  try {
+    f.verify(); f.write(measurement, { ...passed, assisted: true }); assert.equal(f.assess().status, "PASS");
+    const assessment = f.assess(), receipt = json(path.join(f.project, assessment.criteria[0].receipt.path));
+    const captured = receipt.acceptance.criteria[0].checks[0].evidence.path;
+    f.write(captured, { ...passed, assisted: true }); assert.equal(f.assess().status, "UNVERIFIED");
+    assert.throws(() => guardTool(f.project, { tool_name: "Write", tool_input: { file_path: captured } }), /immutable/);
+    assert.equal(safeTaskCommand("node .claude/nccgs/tools/task.mjs acceptance-status --id fixture", f.project), "acceptance-status");
+  } finally { f.dispose(); }
+});
+
+test("pending latest attempt supersedes PASS and owns its measurement paths exclusively", () => {
+  const f = fixture(); let job;
+  try {
+    f.verify(); assert.equal(f.assess().status, "PASS");
+    const args = { name: "runtime", executable: process.execPath, arguments: ["Tools/probe.mjs", JSON.stringify({ data: passed, delayMs: 1000 })], requestKey: "pending" };
+    job = startVerification(f.project, "fixture", args);
+    assert.equal(f.assess().status, "UNVERIFIED");
+    assert.throws(() => startVerification(f.project, "fixture", { ...args, requestKey: "overlap" }), /owns these measurement/);
+    assert.equal(waitVerification(f.project, job.jobId, "fixture", 20000).status, "PASS");
+    assert.equal(f.assess().status, "PASS");
+  } finally { if (job) waitVerification(f.project, job.jobId, "fixture", 20000); f.dispose(); }
+});
+
+test("check-only criteria require mapping and manual criteria keep their owner gate", () => {
+  const f = fixture([{ id: "legacy", description: "Must not infer acceptance from exit 0", check: "runtime" }, { id: "feel", description: "Human playtest", manual: true }]);
+  try {
+    f.verify(); assert.deepEqual(f.assess().criteria.map(c => c.status), ["UNVERIFIED", "MANUAL_PENDING"]);
+    assert.deepEqual(f.task().contract.manualGates, ["feel"]);
+    f.write(".nccgs/bad.json", { ...f.intake, acceptance: [{ ...criteria[0], assertions: [{ artifact: "../outside.json", pointer: "/x", op: "eq", value: true }] }] });
+    assert.throws(() => initialize(f.project, "bad", null, null, null, { intake: ".nccgs/bad.json" }), /measurement/);
+    f.write(".nccgs/bad.json", { ...f.intake, acceptance: [{ ...criteria[0], assertions: [{ artifact: ".nccgs/evidence/measurements/../criteria/x.json", pointer: "/x", op: "eq", value: true }] }] });
+    assert.throws(() => initialize(f.project, "alias", null, null, null, { intake: ".nccgs/bad.json" }), /canonical/);
+  } finally { f.dispose(); }
+});
+
+test("typed thresholds and escaped JSON pointers are evaluated without coercion", () => {
+  const f = fixture([{ id: "load", description: "Measured load", check: "runtime", assertions: [
+    { artifact: measurement, pointer: "/a~1b/~0load", op: "gte", value: 200 },
+    { artifact: measurement, pointer: "/p95", op: "lte", value: 16.7 }] }]);
+  try {
+    f.verify({ "a/b": { "~load": 201 }, p95: 15 }); assert.equal(f.assess().status, "PASS");
+    f.verify({ "a/b": { "~load": "201" }, p95: 15 }); assert.equal(f.assess().status, "UNVERIFIED");
+    f.verify({ "a/b": { "~load": 201 }, p95: 20 }); assert.equal(f.assess().status, "FAIL");
+  } finally { f.dispose(); }
+});
+
+test("early viability blocks expansion while leaving repair, QA and review available", () => {
+  const f = fixture();
+  try {
+    f.worker();
+    assert.throws(() => reserve(f.project, "fixture", f.request()), /Early acceptance checkpoint/);
+    f.verify({ ...passed, assisted: true });
+    assert.throws(() => reserve(f.project, "fixture", f.request()), /Early acceptance checkpoint/);
+    assert.throws(() => reserve(f.project, "fixture", f.request("analysis", { purpose: "qa" })), /reserved for a completed repair/);
+    const repair = f.worker("implementation", { purpose: "repair" }, () => f.write("Assets/game.cs", "// repaired tuning"));
+    assert.equal(f.assess().status, "UNVERIFIED");
+    f.verify();
+    f.worker("analysis", { purpose: "qa" });
+    f.worker();
+    assert.equal(status(f.project, "fixture").deliveryBudget.remaining.repair, 0);
+    assert.ok(repair.dispatchId);
+  } finally { f.dispose(); }
+});
+
+test("STANDARD preserves a repair plus QA plus re-review after initial review at total cap", () => {
+  const f = fixture(criteria.map(c => ({ ...c, checkpoint: "final" })));
+  try {
+    let implementation;
+    for (let i = 0; i < 8; i++) implementation = f.worker();
+    const failed = f.verify({ ...passed, assisted: true }); f.work(implementation, failed);
+    assert.throws(() => reserve(f.project, "fixture", f.request()), /budget reserved/);
+    f.review(f.worker("review"), "CHANGES_REQUIRED");
+    assert.deepEqual(status(f.project, "fixture").deliveryBudget.remaining, { repair: 1, qa: 1, review: 1 });
+    const repair = f.worker("implementation", { purpose: "repair" }, () => f.write("Assets/game.cs", "// bounded correction"));
+    const fresh = f.verify(); f.work(repair, fresh);
+    f.worker("analysis", { purpose: "qa" }); f.review(f.worker("review"));
+    assert.equal(status(f.project, "fixture").usage.dispatches, 12);
+    record(f.project, "fixture", "report", { outcome: "success", summary: "Synthetic repaired acceptance passed" });
+    assert.equal(close(f.project, "fixture").phase, "DONE");
+    assert.throws(() => reserve(f.project, "fixture", f.request()), /budget exhausted/);
+  } finally { f.dispose(); }
+});
+
+test("protected purposes cannot be used without feedback or by an unrelated role", () => {
+  const f = fixture([]);
+  try {
+    assert.throws(() => reserve(f.project, "fixture", f.request("implementation", { purpose: "repair" })), /requires recorded negative/);
+    assert.throws(() => reserve(f.project, "fixture", f.request("implementation", { purpose: "qa" })), /read-only QA/);
+    assert.throws(() => reserve(f.project, "fixture", f.request("analysis", { purpose: "qa", repairFeedback: { fake: true } })), /reserved for a completed repair/);
+    assert.throws(() => reserve(f.project, "fixture", f.request("implementation", { limits: { maxDispatches: 4 } })), /cannot fit/);
+  } finally { f.dispose(); }
+});
+
+test("cancellation, child tasks, input refresh and reclassification cannot refund protected budget", () => {
+  const f = fixture([]);
+  try {
+    for (let i = 0; i < 7; i++) f.worker();
+    f.write(".nccgs/child.json", { ...f.intake, acceptance: [] });
+    initialize(f.project, "child", null, null, null, { intake: ".nccgs/child.json", parentId: "fixture" });
+    const req = f.request("analysis"), child = reserve(f.project, "child", req);
+    const saved = [process.env.CLAUDECODE, process.env.CLAUDE_CODE_ENTRYPOINT];
+    delete process.env.CLAUDECODE; delete process.env.CLAUDE_CODE_ENTRYPOINT;
+    try { reconcile(f.project, child.id, { status: "cancelled", reason: "Synthetic cancelled before launch", reference: "Synthetic fixture" }); }
+    finally { for (const [i, name] of ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"].entries()) if (saved[i] === undefined) delete process.env[name]; else process.env[name] = saved[i]; }
+    assert.equal(status(f.project, "fixture").deliveryBudget.deliveryRemaining, 0);
+    refreshInputs(f.project, "fixture", "Synthetic explicit refresh");
+    reclassify(f.project, "fixture", { risk: "CONTROLLED", reason: "Synthetic escalation", evidence: ["Synthetic observed risk"] });
+    assert.throws(() => reserve(f.project, "fixture", f.request()), /budget reserved/);
+    assert.throws(() => reserve(f.project, "child", f.request("analysis")), /budget reserved/);
+    assert.equal(reserve(f.project, "child", req).id, child.id);
+    assert.equal(status(f.project, "fixture").usage.dispatches, 8);
+  } finally { f.dispose(); }
+});