nccgs 2.0.0-rc.2 → 2.0.0

package/tests/session-budget.test.mjs

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import test from 'node:test';
+import { atomicJson, artifact } from '../.claude/nccgs/tools/policy.mjs';
+import { acquireLock } from '../.claude/nccgs/tools/process-lock.mjs';
+import { sessionBudgetCoverage, sessionBudgetLock } from '../.claude/nccgs/tools/session-budget.mjs';
+
+// Synthetic budgeting fixtures only; no native provider execution claims.
+test('session coverage retains cumulative spend and unknown worker cost; rejects uncovered, stale, corrupt and oversubscribed allowances', () => {
+ const temp=fs.realpathSync(os.tmpdir()), project=fs.mkdtempSync(path.join(temp,'nccgs-session-budget-'));
+ const write=(p,v)=>atomicJson(path.join(project,p),v);
+ write('.nccgs/tasks/root.json',{parentId:null});write('.nccgs/tasks/child.json',{parentId:'root'});
+ const old={id:'old',project,taskId:'root',sessionId:'old-session',costCoverage:'complete',cumulativeCostUsd:2.3,invocations:[]};
+ for(const [i,cost] of [1.1,2.3].entries()) {const p=`.nccgs/runs/old/native-${i}.jsonl`;write(p,{});fs.writeFileSync(path.join(project,p),JSON.stringify({type:'result',session_id:old.sessionId,total_cost_usd:cost})+'\n');old.invocations.push({status:'finished',log:`native-${i}.jsonl`,evidence:artifact(project,p)});}
+ write('.nccgs/runs/old/run.json',old);
+ const current={id:'current',project,taskId:'child',sessionId:'current-session',budgetUsd:9.7,cumulativeCostUsd:0,deadline:Date.now()+100000,status:'running',invocations:[{status:'running',pid:process.pid}]};
+ const lock=acquireLock(path.join(project,sessionBudgetLock),{runId:current.id,sessionId:current.sessionId});
+ const items=[{startedAt:new Date().toISOString(),sessionId:old.sessionId,telemetry:{costUsd:null}}];
+ const coverage=(c=current,limit=12)=>sessionBudgetCoverage(project,'root',items,limit,c,{running:false});
+ try {
+  const result=coverage();assert.equal(result.previousCostUsd,2.3);assert.equal(result.ceilingUsd,12);assert.equal(items[0].telemetry.costUsd,null);assert.equal(result.workerCostInferred,false);
+  assert.throws(()=>coverage({...current,budgetUsd:9.71}),/exceed aggregate/);
+  assert.throws(()=>coverage({...current,deadline:Date.now()-1}),/deadline/);
+  assert.throws(()=>coverage({...current,cumulativeCostUsd:9.7}),/exhausted/);
+  items.push({startedAt:'now',sessionId:'uncovered'});assert.throws(()=>coverage(),/no supervised cost coverage/);items.pop();
+  old.costCoverage='unknown-current-invocation';write('.nccgs/runs/old/run.json',old);assert.throws(()=>coverage(),/unknown/);
+  old.costCoverage='complete';old.cumulativeCostUsd=1.1;write('.nccgs/runs/old/run.json',old);assert.throws(()=>coverage(),/differs/);
+  old.cumulativeCostUsd=2.3;write('.nccgs/runs/old/run.json',old);
+  fs.appendFileSync(path.join(project,'.nccgs/runs/old/native-1.jsonl'),'tamper');assert.throws(()=>coverage(),/stale artifact/);
+  lock.release();assert.throws(()=>coverage());
+ } finally {lock.release();assert.equal(path.dirname(project),temp);assert.ok(path.basename(project).startsWith('nccgs-session-budget-'));fs.rmSync(project,{recursive:true,force:true});}
+});

package/tests/task-slices.test.mjs

@@ -0,0 +1,285 @@
+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 { initializeStandalone, recordStandalone } from "../.claude/nccgs/tools/lifecycle.mjs";
+import { reserve, status, planTaskSlices, taskSliceStatus, rejectUnclaimed, dispatchPrompt } from "../.claude/nccgs/tools/orchestration.mjs";
+import { snapshot } from "../.claude/nccgs/tools/gates.mjs";
+import { observe } from "../.claude/nccgs/tools/runtime.mjs";
+import { guardTool } from "../.claude/nccgs/tools/tool-guard.mjs";
+import { run as taskRun } from "../.claude/nccgs/tools/task.mjs";
+import { slicePromptContext } from "../.claude/nccgs/tools/task-slices.mjs";
+
+// All workers, model observations, design documents and measurements here are
+// SYNTHETIC fixtures. No Claude provider or Unity process is launched.
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+function fixture(parent = false) {
+  const temporaryRoot = fs.realpathSync(os.tmpdir()), project = fs.mkdtempSync(path.join(temporaryRoot, "nccgs-slices-"));
+  const write = (relative, value) => {
+    const file = path.join(project, relative); fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, typeof value === "string" || Buffer.isBuffer(value) ? value : JSON.stringify(value)); return artifact(project, relative);
+  };
+  for (const file of ["pipeline.json", "studio.json"]) write(`.claude/nccgs/${file}`, fs.readFileSync(path.join(root, ".claude/nccgs", file)));
+  write(".nccgs/project.yaml", "schema_version: 2\nmodels:\n  profile: claude-standalone\n");
+  write(".nccgs/execution.json", { schemaVersion: 1, name: "standalone", externalReview: { mode: "off" }, acceptanceRequired: false,
+    requireObservedEffort: false, reviewContractRequired: true, maxParallelWorkers: 2 });
+  write(".nccgs/requirements.yaml", "schema_version: 1\nrequirements: []\n");
+  write("Assets/first.cs", "// SYNTHETIC first file\n"); write("Assets/second.cs", "// SYNTHETIC second file\n");
+  const acceptance = ["first", "second"].map(name => ({ id: `AC-${name}`, description: `Synthetic ${name} acceptance`, check: "integration-check",
+    assertions: [{ artifact: ".nccgs/evidence/measurements/result.json", pointer: `/${name}`, op: "eq", value: true }] }));
+  acceptance.push({ id: "OWNER", description: "Synthetic mandatory owner decision", manual: true });
+  write(".nccgs/intake.json", { schemaVersion: 1, mode: "implement", objective: "SYNTHETIC large task", scope: "feature", target: "production-change", readiness: "ready",
+    acceptance, requiredChecks: ["integration-check"], analysisArtifacts: [".nccgs/evidence/analysis/review-1.md", ".nccgs/evidence/analysis/review-2.md", ".nccgs/evidence/analysis/review-3.md"] });
+  if (parent) initializeStandalone(project, "parent", { intake: ".nccgs/intake.json" });
+  initializeStandalone(project, "large", { intake: ".nccgs/intake.json", ...(parent ? { parentId: "parent" } : {}) });
+  write(".nccgs/runtime/bindings/synthetic-session.json", { taskId: "large" });
+  const task = () => json(path.join(project, ".nccgs/tasks/large.json"));
+  const snap = () => snapshot(project, task()).sha256;
+  const draft = ".nccgs/evidence/slice-plans/plan.json";
+  const plan = () => ({ schemaVersion: 1, taskId: "large", contractHash: task().contractHash, sourceSnapshot: snap(), planId: "plan-one", supersedes: null,
+    reason: "SYNTHETIC bounded decomposition", integration: "integrate", slices: [
+      { id: "first", objective: "Implement the first bounded part", agent: "nccgs-gameplay-programmer", dependsOn: [], writePaths: ["Assets/first.cs"], criteria: ["AC-first"] },
+      { id: "integrate", objective: "Implement second part and integrate the full result", agent: "nccgs-gameplay-programmer", dependsOn: ["first"], writePaths: ["Assets/second.cs"], criteria: ["AC-second", "OWNER"] }
+    ] });
+  const register = (p = plan()) => { write(draft, p); return planTaskSlices(project, "large", draft, true); };
+  let sequence = 0;
+  const start = (request, agentId) => {
+    const dispatch = reserve(project, "large", request), agent = agentId ?? `synthetic-agent-${++sequence}`;
+    const envelope = { hook_event_name: "PreToolUse", session_id: "synthetic-session", tool_name: "Agent", tool_use_id: `tool-${dispatch.id}`,
+      tool_input: { subagent_type: request.agent, prompt: `[NCCGS-DISPATCH:${dispatch.id}] Caller prose cannot replace the slice contract` } };
+    const prompt = guardTool(project, envelope)?.updatedInput?.prompt;
+    observe(project, { session_id: "synthetic-session", agent_id: agent, agent_type: request.agent }, "agent_start");
+    return { dispatch, request, envelope, agentId: agent, prompt };
+  };
+  const finish = (run, { partial = false, model = "claude-opus-5-5" } = {}) => observe(project, { ...run.envelope, tool_response: {
+    agentId: run.agentId, status: "completed", resolvedModel: model, modelsUsed: model ? [model] : [], totalDurationMs: 123, totalTokens: 45,
+    totalToolUseCount: 3, content: partial ? "SYNTHETIC partial" : "SYNTHETIC completed" } }, "agent_result");
+  const deliver = (request = taskSliceStatus(project, "large").next, options = {}) => {
+    const run = start(request);
+    if (!options.partial) for (const [index, file] of request.writePaths.entries()) {
+      guardTool(project, { session_id: "synthetic-session", agent_id: run.agentId, tool_use_id: `write-${run.dispatch.id}-${index}`, tool_name: "Write", tool_input: { file_path: file, content: "synthetic" } });
+      write(file, `// SYNTHETIC change from ${run.dispatch.id}\n`);
+    }
+    write(request.handoffPaths[0], `NCCGS-HANDOFF: ${options.partial ? "PARTIAL" : "COMPLETE"}\nSynthetic handoff, never acceptance proof.`);
+    return { ...run, observed: finish(run, options) };
+  };
+  const verify = (second = true) => {
+    write(".nccgs/verify.mjs", `import fs from 'node:fs'; fs.mkdirSync('.nccgs/evidence/measurements',{recursive:true}); fs.writeFileSync('.nccgs/evidence/measurements/result.json',JSON.stringify({first:true,second:${second}})); console.log('SYNTHETIC measurement fixture only');`);
+    return taskRun(["verify", "--project", project, "--id", "large", "--name", "integration-check", "--", process.execPath, ".nccgs/verify.mjs"]);
+  };
+  const stage = (run, verification) => ({ snapshot: run.observed.snapshot, dispatchId: run.dispatch.id, runtime: artifact(project, run.observed.path),
+    checks: [{ name: "integration-check", status: verification.status, evidence: verification.evidence }] });
+  const review = (number = 1, agentId, verdict = "PASS", conditions = []) => {
+    const file = `.nccgs/evidence/analysis/review-${number}.md`;
+    const run = start({ kind: "review", agent: "nccgs-adversarial-reviewer", requestKey: `review-${number}`, reason: "SYNTHETIC independent integrated review", writePaths: [], handoffPaths: [file] }, agentId);
+    write(file, `NCCGS-HANDOFF: COMPLETE\n\n\`\`\`nccgs-review\n${JSON.stringify({ schemaVersion: 1, taskId: "large", contractHash: task().contractHash, snapshot: snap(),
+      verdict, criteriaMet: verdict === "PASS", findings: [], conditions })}\n\`\`\`\n`);
+    const observed = finish(run);
+    return { ...run, observed, record: () => taskRun(["record-review", "--project", project, "--id", "large", "--dispatch", run.dispatch.id, "--file", file]) };
+  };
+  return { project, write, task, snap, draft, plan, register, start, finish, deliver, verify, stage, review,
+    dispose() {
+      assert.equal(path.dirname(project).toLowerCase(), temporaryRoot.toLowerCase()); assert.ok(path.basename(project).startsWith("nccgs-slices-"));
+      assert.equal(fs.lstatSync(project).isSymbolicLink(), false); assert.equal(fs.realpathSync(project).toLowerCase(), project.toLowerCase());
+      fs.rmSync(project, { recursive: true, force: true });
+    } };
+}
+
+test("slice preview/registration preserve the full task and budgets; injected contexts select original criteria", () => {
+  const f = fixture();
+  try {
+    const original = fs.readFileSync(path.join(f.project, ".nccgs/tasks/large.json")), plan = f.plan(); f.write(f.draft, plan);
+    const preview = planTaskSlices(f.project, "large", f.draft);
+    assert.equal(preview.status, "PREVIEW"); assert.equal(fs.existsSync(path.join(f.project, ".nccgs/orchestration.json")), false);
+    assert.equal(preview.budgets[0].minimumRemainingSlices, 2); assert.equal(preview.budgets[0].protectedSlots, 4);
+    const saved = f.register(plan), ledger = fs.readFileSync(path.join(f.project, ".nccgs/orchestration.json"));
+    assert.equal(f.register(plan).status, "ALREADY_REGISTERED");
+    assert.deepEqual(fs.readFileSync(path.join(f.project, ".nccgs/orchestration.json")), ledger);
+    assert.deepEqual(fs.readFileSync(path.join(f.project, ".nccgs/tasks/large.json")), original);
+    assert.equal(status(f.project, "large").usage.dispatches, 0);
+    const run = f.start(taskSliceStatus(f.project, "large").next);
+    assert.ok(run.prompt.startsWith(`[NCCGS-DISPATCH:${run.dispatch.id}]`));
+    assert.match(run.prompt, /AC-first/); assert.doesNotMatch(run.prompt, /AC-second/);
+    assert.match(run.prompt, /same task.*shared budget/i);
+    const contextTask = structuredClone(f.task());
+    contextTask.contract.design = { document: f.write(".nccgs/evidence/synthetic-design.json", { requirements: [
+      { id: "REQ-A", criteria: ["AC-first"], rules: "Preserve exact fixed rule A" }, { id: "REQ-B", criteria: ["AC-second"], rules: "Fixed rule B" }
+    ], decisions: [{ resolution: "Keep the global decision" }], outOfScope: ["No product changes"] }) };
+    const context = slicePromptContext(f.project, contextTask, run.dispatch);
+    assert.match(context, /Preserve exact fixed rule A/); assert.doesNotMatch(context, /Fixed rule B/); assert.match(context, /Keep the global decision/);
+    assert.throws(() => guardTool(f.project, { session_id: "synthetic-session", tool_name: "Write", tool_input: { file_path: saved.reference.path } }), /immutable/);
+    assert.throws(() => guardTool(f.project, { session_id: "synthetic-session", agent_id: run.agentId, tool_name: "Write", tool_input: { file_path: "Assets/second.cs" } }), /exact planned file/);
+  } finally { f.dispose(); }
+});
+
+test("slices reject omitted criteria, scope expansion, cycles and unaffordable decomposition without mutation", () => {
+  const f = fixture();
+  try {
+    const base = f.plan();
+    const variants = [
+      { ...base, acceptance: [] }, { ...base, budgets: { maxDispatches: 999 } }, { ...base, risk: "FAST" }, { ...base, sourceSnapshot: "stale" },
+      { ...base, slices: [base.slices[0], { ...base.slices[1], criteria: ["AC-second"] }] },
+      { ...base, slices: [base.slices[0], { ...base.slices[1], criteria: ["AC-first", "AC-second", "OWNER"] }] },
+      { ...base, slices: [{ ...base.slices[0], dependsOn: ["integrate"] }, base.slices[1]] },
+      { ...base, slices: [base.slices[0], { ...base.slices[1], dependsOn: [] }] },
+      { ...base, slices: [{ ...base.slices[0], writePaths: ["Assets"] }, base.slices[1]] },
+      { ...base, slices: [{ ...base.slices[0], writePaths: [".nccgs/tasks/large.json"] }, base.slices[1]] },
+      { ...base, slices: [{ ...base.slices[0], agent: "nccgs-adversarial-reviewer" }, base.slices[1]] }
+    ];
+    const many = Array.from({ length: 9 }, (_, i) => ({ id: `part-${i}`, objective: "Synthetic small unit", agent: "nccgs-gameplay-programmer",
+      dependsOn: i === 8 ? Array.from({ length: 8 }, (_, j) => `part-${j}`) : [], writePaths: [`Assets/part-${i}.cs`], criteria: i === 0 ? ["AC-first", "AC-second", "OWNER"] : [] }));
+    variants.push({ ...base, slices: many, integration: "part-8" });
+    for (const plan of variants) {
+      f.write(f.draft, plan); assert.throws(() => planTaskSlices(f.project, "large", f.draft, true));
+      assert.equal(fs.existsSync(path.join(f.project, ".nccgs/orchestration.json")), false);
+    }
+    f.register(); const before = fs.readFileSync(path.join(f.project, ".nccgs/orchestration.json"));
+    const request = taskSliceStatus(f.project, "large").next;
+    for (const changed of [{ ...request, sliceId: "integrate", agent: base.slices[1].agent, writePaths: base.slices[1].writePaths },
+      { ...request, sliceId: undefined }, { ...request, writePaths: ["Assets"] }, { ...request, agent: "nccgs-engine-programmer" }]) {
+      assert.throws(() => reserve(f.project, "large", changed));
+      assert.deepEqual(fs.readFileSync(path.join(f.project, ".nccgs/orchestration.json")), before);
+    }
+  } finally { f.dispose(); }
+});
+
+test("integrated slices require current full measurements, independent review of every contributor and original manual acceptance", () => {
+  const f = fixture();
+  try {
+    const original = f.task(); f.register();
+    const first = f.deliver(), earlyCheck = f.verify();
+    assert.throws(() => recordStandalone(f.project, f.task(), "implementation", f.stage(first, earlyCheck)), /All planned slices/);
+    assert.throws(() => f.review(), /implementation.*missing|stale/);
+    const integrated = f.deliver();
+    assert.match(integrated.prompt, /AC-first/); assert.match(integrated.prompt, /AC-second/); assert.match(integrated.prompt, /OWNER/);
+    assert.throws(() => recordStandalone(f.project, f.task(), "implementation", f.stage(integrated, earlyCheck)), /Verification execution failed or stale/);
+    const failedMeasure = f.verify(false);
+    recordStandalone(f.project, f.task(), "implementation", f.stage(integrated, failedMeasure));
+    const negative = f.review(1, undefined, "CHANGES_REQUIRED", [{ id: "C1", description: "Second original criterion is still false" }]);
+    negative.record(); assert.equal(f.task().stages.review.conditions[0].id, "C1");
+    assert.throws(() => recordStandalone(f.project, f.task(), "report", { outcome: "success", summary: "Cannot waive criterion" }), /criteria failed|not passed/);
+    // A fresh measured check, without mutating source or historical observations.
+    f.verify(true);
+    const formerContributor = f.review(2, first.agentId);
+    assert.throws(() => formerContributor.record(), /independent of every implementation contributor/);
+    const independent = f.review(3); independent.record();
+    assert.throws(() => reserve(f.project, "large", { ...first.request, requestKey: "no-extra-review",
+      handoffPaths: [".nccgs/evidence/analysis/no-extra-review.md"] }), /independent-review budget exhausted/);
+    recordStandalone(f.project, f.task(), "report", { outcome: "success", summary: "Synthetic technical result, manual decision pending" });
+    assert.throws(() => taskRun(["close", "--project", f.project, "--id", "large"]), /acceptance: missing/);
+    assert.deepEqual(f.task().contract, original.contract);
+    assert.equal(f.task().reviewBudget.limit, original.reviewBudget.limit); assert.equal(f.task().reviewBudget.used, 2);
+    assert.ok(f.task().history.some(h => h.stages?.review?.verdict === "CHANGES_REQUIRED"));
+    assert.equal(status(f.project, "large").usage.dispatches, 5);
+  } finally { f.dispose(); }
+});
+
+test("slice retries and revisions preserve failed attempts, invalidate dependent work and never reset budget", () => {
+  const f = fixture();
+  try {
+    const plan = f.plan(); f.register(plan);
+    const failed = f.deliver(undefined, { partial: true });
+    assert.equal(taskSliceStatus(f.project, "large").slices[0].state, "PARTIAL");
+    const revision = { ...plan, planId: "plan-two", supersedes: "plan-one", sourceSnapshot: f.snap(), reason: "Refine only unattempted integration", slices: structuredClone(plan.slices) };
+    revision.slices[1].objective = "Refined integration assignment";
+    f.register(revision); assert.equal(taskSliceStatus(f.project, "large").slices[0].attempts[0].dispatchId, failed.dispatch.id);
+    const changed = structuredClone(revision); changed.planId = "plan-three"; changed.supersedes = "plan-two";
+    changed.slices[0].id = "hide-first"; changed.slices[1].dependsOn = ["hide-first"];
+    assert.throws(() => f.register(changed), /attempted slice first cannot be removed or renamed/);
+    const first = f.deliver(), second = f.deliver();
+    assert.equal(taskSliceStatus(f.project, "large").slices[1].state, "DELIVERED");
+    const retry = { ...first.request, requestKey: "explicit-first-retry", handoffPaths: [".nccgs/evidence/analysis/first-retry.md"] };
+    f.deliver(retry);
+    const progress = taskSliceStatus(f.project, "large");
+    assert.equal(progress.slices[1].state, "STALE"); assert.equal(progress.next.sliceId, "integrate");
+    assert.equal(progress.slices[1].dispatchId, second.dispatch.id);
+    assert.equal(status(f.project, "large").usage.dispatches, 4);
+    const expanded = structuredClone(revision); expanded.planId = "plan-three"; expanded.supersedes = "plan-two"; expanded.sourceSnapshot = f.snap();
+    expanded.reason = "Explicitly refine the attempted slice without resetting its history"; expanded.slices[0].writePaths.push("Assets/focused-regression.cs");
+    f.register(expanded);
+    assert.equal(taskSliceStatus(f.project, "large").slices[0].state, "STALE");
+    assert.equal(taskSliceStatus(f.project, "large").slices[0].attempts.length, 3);
+    f.write(f.draft, plan); assert.equal(planTaskSlices(f.project, "large", f.draft, true).status, "SUPERSEDED");
+    assert.equal(taskSliceStatus(f.project, "large").planId, "plan-three");
+    assert.equal(f.task().history.length, 0); // Planning never rewrites lifecycle history/stages.
+  } finally { f.dispose(); }
+});
+
+test("slice allocation protects ancestor dispatch, cost and duration budgets", () => {
+  for (const metric of ["cost", "duration"]) {
+  const f = fixture(true);
+  try {
+    const request = { kind: "analysis", agent: "nccgs-task-scout", requestKey: "prior-parent", reason: "SYNTHETIC existing parent allocation", writePaths: [],
+      limits: { maxDispatches: 7, ...(metric === "cost" ? { maxCostUsd: 1 } : { maxDurationMs: 100 }) } };
+    const old = reserve(f.project, "parent", request);
+    rejectUnclaimed(f.project, old.id, { sessionId: "never-launched", toolUseId: "old", agent: request.agent, reason: "SYNTHETIC rejected launch, no refund" });
+    const registered = f.register();
+    assert.equal(registered.budgets.find(b => b.taskId === "parent").spareDispatches, 0);
+    assert.throws(() => reserve(f.project, "parent", { ...request, requestKey: "steal-integration" }), /cannot fit/);
+    assert.equal(status(f.project, "parent").usage.dispatches, 1);
+    f.deliver();
+    assert.throws(() => reserve(f.project, "large", taskSliceStatus(f.project, "large").next), metric === "cost" ? /missing costUsd telemetry/ : /maxDurationMs budget exhausted/);
+    assert.equal(status(f.project, "parent").limits[metric === "cost" ? "maxCostUsd" : "maxDurationMs"], metric === "cost" ? 1 : 100);
+    assert.equal(status(f.project, "parent").limits.maxDispatches, 7);
+    assert.equal(status(f.project, "parent").usage.dispatches, 2);
+  } finally { f.dispose(); }
+  }
+});
+
+test("integrated task slices retain the existing bounded repair and independent re-review path", () => {
+  const f = fixture();
+  try {
+    const original = f.task(); f.register(); f.deliver(); const integrated = f.deliver();
+    recordStandalone(f.project, f.task(), "implementation", f.stage(integrated, f.verify(false)));
+    f.review(1, undefined, "CHANGES_REQUIRED", [{ id: "FIX", description: "Correct second behavior without changing its criterion" }]).record();
+    const workPacket = ".nccgs/evidence/work-packets/repair.json";
+    f.write(workPacket, { schemaVersion: 1, taskId: "large", contractHash: f.task().contractHash,
+      sourceSnapshot: f.snap(), problem: "Synthetic second behavior fails the original criterion", solution: "Correct only second behavior",
+      changes: [{ path: "Assets/second.cs", instruction: "Apply the chosen correction" }], context: [], verification: ["integration-check"],
+      budget: { workCalls: 12, readCalls: 6, handoffCalls: 3, durationMs: 600000 } });
+    const repaired = f.deliver({ kind: "implementation", purpose: "repair", agent: "nccgs-gameplay-programmer", requestKey: "bounded-repair",
+      reason: "SYNTHETIC repair against recorded feedback", writePaths: ["Assets/second.cs"], workPacket,
+      handoffPaths: [".nccgs/evidence/analysis/repair-result.md"] });
+    recordStandalone(f.project, f.task(), "implementation", f.stage(repaired, f.verify(true)));
+    f.review(2).record();
+    assert.equal(f.task().stages.implementation.dispatchId, repaired.dispatch.id);
+    assert.equal(f.task().stages.review.verdict, "PASS");
+    assert.equal(f.task().reviewBudget.used, 2); assert.equal(f.task().reviewBudget.limit, original.reviewBudget.limit);
+    assert.deepEqual(f.task().contract, original.contract);
+    assert.ok(f.task().history.some(h => h.stages?.review?.verdict === "CHANGES_REQUIRED"));
+    assert.equal(taskSliceStatus(f.project, "large").next, null);
+    assert.equal(status(f.project, "large").usage.dispatches, 5);
+  } finally { f.dispose(); }
+});
+
+test("slice closure rejects missing native model, tampered handoffs or deleted plan history", () => {
+  for (const variant of ["model", "handoff", "plan", "history"]) {
+    const f = fixture();
+    try {
+      const registration = f.register(), delivered = f.deliver(undefined, { model: variant === "model" ? null : "claude-opus-5-5" });
+      if (variant === "handoff") f.write(delivered.request.handoffPaths[0], "SYNTHETIC tampering");
+      if (variant === "plan") f.write(registration.reference.path, "{}");
+      if (variant === "history") {
+        const ledger = json(path.join(f.project, ".nccgs/orchestration.json")); delete ledger.tasks.large.slicePlan; f.write(".nccgs/orchestration.json", ledger);
+      }
+      if (["model", "handoff"].includes(variant)) {
+        const state = taskSliceStatus(f.project, "large"); assert.equal(state.slices[0].state, "BLOCKED");
+        assert.equal(state.slices[1].ready, false);
+      } else assert.throws(() => taskSliceStatus(f.project, "large"), /stale artifact|history missing/);
+    } finally { f.dispose(); }
+  }
+});
+
+test("slice commands reject budget overrides and workers cannot register plans", () => {
+  const f = fixture();
+  try {
+    f.register(); const run = f.start(taskSliceStatus(f.project, "large").next);
+    for (const extra of [["--file", "second.json"], ["--budget", "999"], ["--", "node"]]) assert.throws(() => taskRun([
+      "slice-preview", "--project", f.project, "--id", "large", "--file", f.draft, ...extra]), /unique/);
+    assert.throws(() => guardTool(f.project, { session_id: "synthetic-session", agent_id: run.agentId, tool_name: "Bash", tool_input: {
+      command: `node .claude/nccgs/tools/task.mjs slice-plan --id large --file ${f.draft}` } }), /Coordinator owns lifecycle/);
+  } finally { f.dispose(); }
+});

package/tests/unity-generated.test.mjs

@@ -0,0 +1,140 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import {fileURLToPath} from 'node:url';
+import {initialize, snapshot} from '../.claude/nccgs/tools/gates.mjs';
+import {inputPolicy} from '../.claude/nccgs/tools/inputs.mjs';
+import {json} from '../.claude/nccgs/tools/policy.mjs';
+import {startVerification, waitVerification} from '../.claude/nccgs/tools/verification-jobs.mjs';
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const outputs=['Game.csproj','Game.Tests.csproj','Game.slnx','.vscode/extensions.json','.vscode/launch.json','.vscode/settings.json','UserSettings/EditorUserSettings.asset','UserSettings/Search.settings'];
+function fixture(enabled=true) {
+  const parent=fs.realpathSync(os.tmpdir()),project=fs.mkdtempSync(path.join(parent,'nccgs-unity-inputs-'));
+  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));};
+  fs.cpSync(path.join(root,'.claude/nccgs/tools'),path.join(project,'.claude/nccgs/tools'),{recursive:true});
+  for(const name of ['pipeline.json','studio.json'])write('.claude/nccgs/'+name,fs.readFileSync(path.join(root,'.claude/nccgs',name),'utf8'));
+  write('Assets/Game.cs','// unchanged game source');
+  write('Packages/manifest.json',{dependencies:{}});
+  write('ProjectSettings/ProjectVersion.txt','m_EditorVersion: 6000.3.17f1\n');
+  write('.nccgs/project.yaml','schema_version: 2\nmodels:\n  profile: claude-standalone\n');
+  write('.nccgs/execution.json',{schemaVersion:1,name:'standalone',externalReview:{mode:'off'}});
+  const policy={schemaVersion:1,canonicalInputs:[],outputDirectories:[],checks:{fixture:{timeoutMs:15000}},...(enabled?{unityGeneratedFiles:outputs}:{})};
+  write('.nccgs/inputs.json',policy);
+  write('.nccgs/intake.json',{objective:'Synthetic source protection check, not Unity/provider execution',mode:'implement',requiredChecks:['fixture']});
+  initialize(project,'fixture',null,null,null,{intake:'.nccgs/intake.json'});
+  let count=0;
+  const run=(code,key='attempt-'+(++count))=>startVerification(project,'fixture',{name:'fixture',executable:process.execPath,arguments:['-e',code],requestKey:key});
+  const finish=job=>{const result=waitVerification(project,job.jobId,'fixture',20000);return {result,receipt:json(path.join(project,result.evidence.path))};};
+  const dispose=()=>{assert.equal(path.dirname(fs.realpathSync(project)),parent);assert.ok(path.basename(project).startsWith('nccgs-unity-inputs-'));fs.rmSync(project,{recursive:true,force:true});};
+  return {project,write,policy,run,finish,dispose};
+}
+const generation=`const fs=require('node:fs'),path=require('node:path');for(const name of ${JSON.stringify(outputs)}){fs.mkdirSync(path.dirname(name),{recursive:true});fs.writeFileSync(name,'synthetic generated metadata');}`;
+
+test('Unity outputs are opt-in, exact paths, and their creation remains auditable',()=>{
+  const f=fixture();
+  try {
+    const before=snapshot(f.project);
+    for(const name of outputs)f.write(name,'synthetic generated metadata');
+    const after=snapshot(f.project);
+    assert.equal(after.sha256,before.sha256);
+    assert.equal(after.sourceSha256,before.sourceSha256);
+    assert.equal(before.unityGeneratedFiles.every(file=>file.sha256===null),true);
+    assert.equal(after.unityGeneratedFiles.every(file=>/^[a-f0-9]{64}$/.test(file.sha256)),true);
+    const protectedFiles=['Assets/new.cs','Assets/Scene.unity','Assets/Scene.unity.meta','Assets/test.asmdef','Assets/Tests/Test.cs',
+      'Packages/new.json','ProjectSettings/EditorBuildSettings.asset','Tools/Build.csproj','Custom.csproj','Custom.sln',
+      '.vscode/tasks.json','.vscode/custom.json','UserSettings/source.cs','UserSettings/custom.asset','new.cs'];
+    for(const name of protectedFiles) {
+      f.write(name,'unexpected change');
+      assert.notEqual(snapshot(f.project).sha256,before.sha256,name);
+      fs.unlinkSync(path.join(f.project,name));
+      assert.equal(snapshot(f.project).sha256,before.sha256);
+    }
+    f.write('Assets/Game.cs','// mutation');assert.notEqual(snapshot(f.project).sha256,before.sha256);
+    fs.unlinkSync(path.join(f.project,'Assets/Game.cs'));assert.notEqual(snapshot(f.project).sha256,before.sha256);
+  } finally {f.dispose();}
+});
+
+test('Existing policy without Unity outputs preserves its old strict snapshot semantics',()=>{
+  const f=fixture(false);
+  try {
+    const before=snapshot(f.project);
+    assert.equal(before.unityGeneratedFiles,undefined);
+    for(const name of outputs) {
+      f.write(name,'metadata remains tracked');assert.notEqual(snapshot(f.project).sha256,before.sha256);
+      fs.unlinkSync(path.join(f.project,name));assert.equal(snapshot(f.project).sha256,before.sha256);
+    }
+  } finally {f.dispose();}
+});
+
+test('Unity metadata policy rejects source paths, globs, directories, overlaps and malformed declarations',()=>{
+  const f=fixture();
+  try {
+    for(const value of [null,true,'*.csproj',['Assets/Game.cs'],['Assets/Game.csproj'],['Tools/Build.csproj'],['ProjectSettings/EditorBuildSettings.asset'],
+      ['Packages/manifest.json'],['.vscode/tasks.json'],['UserSettings'],['*.csproj'],['../Game.csproj'],['C:/Game.csproj'],
+      ['Game.csproj','game.csproj'],Array(257).fill('Game.csproj')]) {
+      f.write('.nccgs/inputs.json',{...f.policy,unityGeneratedFiles:value});assert.throws(()=>inputPolicy(f.project),undefined,JSON.stringify(value));
+    }
+    for(const canonical of ['Game.csproj','.vscode','UserSettings/EditorUserSettings.asset','GAME.CSPROJ']) {
+      f.write('.nccgs/inputs.json',{...f.policy,canonicalInputs:[canonical]});assert.throws(()=>inputPolicy(f.project),/overlap/);
+    }
+    f.write('.nccgs/inputs.json',f.policy);fs.mkdirSync(path.join(f.project,'Game.csproj'));
+    assert.throws(()=>inputPolicy(f.project),/not a file/);
+  } finally {f.dispose();}
+});
+
+test('Unity metadata declarations cannot apply to non-Unity projects or silently refresh task inputs',()=>{
+  const f=fixture();
+  try {
+    const before=snapshot(f.project),taskPath=path.join(f.project,'.nccgs/tasks/fixture.json'),original=fs.readFileSync(taskPath);
+    f.write('.nccgs/inputs.json',{...f.policy,unityGeneratedFiles:outputs.slice(1)});
+    const after=snapshot(f.project);
+    assert.notEqual(after.sha256,before.sha256);assert.notEqual(after.canonicalInputSha256,before.canonicalInputSha256);
+    assert.deepEqual(fs.readFileSync(taskPath),original);
+    fs.unlinkSync(path.join(f.project,'ProjectSettings/ProjectVersion.txt'));
+    assert.throws(()=>snapshot(f.project),/requires a Unity project/);
+  } finally {f.dispose();}
+});
+
+test('Managed first-run generation passes with a frozen output delta and idempotent request',()=>{
+  const f=fixture();
+  try {
+    const job=f.run(generation,'first-run'),{result,receipt}=f.finish(job);
+    assert.equal(result.status,'PASS');assert.equal(receipt.sourceUnchanged,true);
+    assert.equal(receipt.unityGeneratedFiles.changes.length,outputs.length);
+    assert.ok(receipt.unityGeneratedFiles.changes.every(c=>c.beforeSha256===null&&/^[a-f0-9]{64}$/.test(c.afterSha256)));
+    const original=fs.readFileSync(path.join(f.project,result.evidence.path));
+    assert.deepEqual(f.run(generation,'first-run').evidence,result.evidence);
+    f.write(outputs[0],'another generated version');
+    assert.deepEqual(fs.readFileSync(path.join(f.project,result.evidence.path)),original);
+    const next=f.finish(f.run("require('node:fs').writeFileSync('Game.csproj','next version')"));
+    assert.equal(next.result.status,'PASS');assert.equal(next.receipt.unityGeneratedFiles.changes.length,1);
+    assert.notEqual(next.receipt.unityGeneratedFiles.changes[0].beforeSha256,next.receipt.unityGeneratedFiles.changes[0].afterSha256);
+  } finally {f.dispose();}
+});
+
+test('Generated files never mask real source changes or undeclared IDE writes in managed verification',()=>{
+  const f=fixture();
+  try {
+    const changed=f.finish(f.run(generation+"require('node:fs').writeFileSync('Assets/Game.cs','changed source')"));
+    assert.equal(changed.result.status,'FAIL');assert.equal(changed.receipt.sourceUnchanged,false);
+    assert.equal(changed.receipt.unityGeneratedFiles.changes.length,outputs.length);
+    const ide=f.finish(f.run("require('node:fs').writeFileSync('.vscode/tasks.json','custom tool config')"));
+    assert.equal(ide.result.status,'FAIL');assert.equal(ide.receipt.sourceUnchanged,false);
+    const exit=f.finish(f.run('process.exitCode=7;'));
+    assert.equal(exit.result.status,'FAIL');assert.equal(exit.receipt.exitCode,7);
+  } finally {f.dispose();}
+});
+
+test('Generated-only writes cannot mask a managed timeout',()=>{
+  const f=fixture();
+  try {
+    const job=startVerification(f.project,'fixture',{name:'fixture',executable:process.execPath,
+      arguments:['-e',generation+'setTimeout(()=>{},30000);'],timeoutMs:3000,requestKey:'generated-timeout'});
+    const {result,receipt}=f.finish(job);
+    assert.equal(result.status,'FAIL');assert.equal(receipt.timedOut,true);
+    assert.equal(receipt.sourceUnchanged,true);
+    assert.equal(receipt.unityGeneratedFiles.changes.length,outputs.length);
+  } finally {f.dispose();}
+});