nccgs 2.0.0 → 2.1.1

package/tests/lifecycle-v15.test.mjs

@@ -1,300 +1,346 @@
-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 { fileURLToPath } from "node:url";
-import test from "node:test";
-import { artifact, atomicJson, json } from "../.claude/nccgs/tools/policy.mjs";
-import { initialize, snapshot, record, check, close, taskPath, reclassify, refreshInputs, importExternal, exportExternal, extendReview } from "../.claude/nccgs/tools/gates.mjs";
-import { reserve, claim, complete, status, resume } from "../.claude/nccgs/tools/orchestration.mjs";
-import { run } from "../.claude/nccgs/tools/task.mjs";
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-// All provider observations below are synthetic fixtures. They verify framework
-// evidence mechanics, not actual Claude Code/model execution or game quality.
-function fixture(options = {}) {
-  const project = fs.mkdtempSync(path.join(os.tmpdir(), "nccgs-lifecycle-v15-"));
-  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);
-  };
-  for (const name of ["pipeline.json", "studio.json"]) write(`.claude/nccgs/${name}`, fs.readFileSync(path.join(root, ".claude/nccgs", name), "utf8"));
-  write(".nccgs/project.yaml", "schema_version: 2\nmodels:\n  profile: claude-standalone\n");
-  write(".nccgs/execution.json", { schemaVersion: 1, name: "standalone", externalReview: { mode: options.external || "off" }, acceptanceRequired: options.acceptance || false, requireObservedEffort: options.strictEffort || false });
-  write("Assets/game.cs", "// source baseline\n");
-  const contract = { schemaVersion: 1, objective: "Implement a bounded enemy feedback feature", mode: options.mode || "implement", scope: "feature", target: "production-change", readiness: "ready", requiredChecks: ["verification"], ...options.contract };
-  write(".nccgs/intake.json", contract);
-  initialize(project, "feature", null, null, null, { intake: ".nccgs/intake.json" });
-  let index = 0;
-  const task = () => json(taskPath(project, "feature"));
-  const snap = () => snapshot(project, task()).sha256;
-  function attempt(kind, rawOverrides = {}) {
-    const current = task(), count = ++index, agent = kind === "review" ? "nccgs-adversarial-reviewer" : kind === "analysis" ? "nccgs-task-scout" : "nccgs-gameplay-programmer";
-    const d = reserve(project, "feature", { kind, agent, requestKey: `request-${count}`, reason: `Synthetic fixture ${kind}`, writePaths: kind === "implementation" ? ["Assets/game.cs"] : [], limits: { maxDispatches: 100 } });
-    claim(project, d.id, { sessionId: "fixture-session", toolUseId: `tool-${count}`, agent });
-    const route = kind === "review" ? current.execution.profile.models.review : current.implementationRoute;
-    const model = route.model === "sonnet" ? "claude-sonnet-4-6" : route.model === "opus" ? "claude-opus-5-5" : route.model;
-    const source = `.nccgs/evidence/raw-${count}.json`;
-    write(source, { taskId: "feature", 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: model, observedEffort: options.strictEffort ? route.effort : null,
-      provenance: { kind: "provider-log", reference: "SYNTHETIC TEST FIXTURE, not actual Claude Code execution" }, ...rawOverrides });
-    const runtime = run(["observe", "--project", project, "--id", "feature", "--file", source]);
-    complete(project, d.id, { runtime });
-    return { snapshot: snap(), dispatchId: d.id, runtime };
-  }
-  function work(overrides = {}, raw = {}) {
-    const name = task().mode === "implement" ? "implementation" : "analysis";
-    const input = { ...attempt(name, raw), checks: [{ name: "verification", status: "PASS", evidence: write(`.nccgs/evidence/check-${++index}.md`, "Fixture source reasoning / acceptance verification: PASS") }], ...overrides };
-    if (name === "analysis" && !input.evidence) input.evidence = write(task().contract.analysisArtifacts[0], "# Fixture analysis\n\nSource observations and recommendations.");
-    return record(project, "feature", name, input);
-  }
-  const review = (overrides = {}, raw = {}) => record(project, "feature", "review", { ...attempt("review", raw), verdict: "PASS", criteriaMet: true, findings: [], evidence: write(`.nccgs/evidence/review-${++index}.md`, "Fixture independent review: no open findings"), ...overrides });
-  const report = (outcome = "success", overrides = {}) => record(project, "feature", "report", { outcome, summary: `Fixture ${outcome} report. No real model/game execution claimed.`, ...overrides });
-  function receipt(overrides = {}) {
-    const relative = `.nccgs/evidence/receipt-${++index}.json`;
-    write(relative, { schemaVersion: 1, id: `receipt-${index}`, taskId: "feature", contractHash: task().contractHash, snapshot: snap(), actor: "External fixture reviewer", verdict: "PASS", findings: [], reviewedAt: new Date().toISOString(), source: "fixture external review event", ...overrides });
-    return relative;
-  }
-  return { project, contract, write, task, snap, attempt, work, review, report, receipt,
-    dispose() { const resolved = path.resolve(project); assert.ok(resolved.startsWith(path.resolve(os.tmpdir()) + path.sep + "nccgs-lifecycle-v15-")); fs.rmSync(resolved, { recursive: true, force: true }); } };
-}
-
-test("standalone finishes without Astra or acceptance while preserving UNKNOWN effort", () => {
-  const f = fixture();
-  try {
-    assert.equal(f.task().schemaVersion, 2);
-    assert.equal(f.task().risk, "STANDARD");
-    assert.equal(f.task().implementationRoute.model, "opus");
-    assert.throws(() => close(f.project, "feature"), /implementation: missing/);
-    f.work(); f.review(); f.report();
-    const result = close(f.project, "feature");
-    assert.equal(result.phase, "DONE");
-    assert.equal(result.acceptanceRequired, false);
-    assert.equal(result.executionEvidence.effortEvidence, "UNKNOWN");
-    assert.equal(result.executionEvidence.observedEffort, null);
-    assert.deepEqual(Object.keys(f.task().stages), ["implementation", "review", "report"]);
-  } finally { f.dispose(); }
-});
-
-test("classifier uses concrete signals, rejects unsafe overrides and supports direct text intake", () => {
-  const fast = fixture({ contract: { objective: "Fix one UI label alignment", scope: "local", target: "fix" } });
-  const controlled = fixture({ contract: { objective: "Migrate the save serialization format", scope: "local" } });
-  try {
-    assert.equal(fast.task().risk, "FAST");
-    assert.equal(fast.task().implementationRoute.model, "sonnet");
-    assert.ok(fast.task().classification.evidence.length);
-    assert.equal(controlled.task().risk, "CONTROLLED");
-    assert.match(controlled.task().classification.reason, /save\/serialization|migration/);
-    assert.throws(() => reclassify(controlled.project, "feature", { risk: "FAST", reason: "Only one file", evidence: ["One file changed"] }), /require CONTROLLED/);
-    fast.write(".nccgs/request.md", "Review feasibility of the enemy feedback design. Produce a plan only.");
-    const planned = run(["init", "--project", fast.project, "--id", "direct-plan", "--intake", ".nccgs/request.md", "--mode", "plan"]);
-    assert.equal(planned.mode, "plan");
-    assert.equal(planned.risk, "STANDARD");
-    assert.deepEqual(planned.contract.analysisArtifacts, [".nccgs/evidence/analysis/direct-plan-result.md"]);
-    assert.throws(() => initialize(fast.project, "bad", null, null, "FAST", { intake: ".nccgs/intake.json" }), /classification reason/);
-    assert.throws(() => initialize(fast.project, "incomplete", null, null, "FAST", { intake: ".nccgs/request.md", reason: "Assumed small" }), /ready local fix/);
-  } finally { fast.dispose(); controlled.dispose(); }
-});
-
-test("audit and plan use analysis evidence and fail if source changes", () => {
-  for (const mode of ["audit", "plan"]) {
-    const f = fixture({ mode });
-    try {
-      assert.throws(() => reserve(f.project, "feature", { kind: "implementation", agent: "nccgs-gameplay-programmer", requestKey: "bad", reason: "Wrong mode", writePaths: ["Assets/game.cs"] }), /cannot dispatch implementation/);
-      const old = process.env.CLAUDECODE;
-      try {
-        process.env.CLAUDECODE = "1";
-        assert.throws(() => run(["verify", "--project", f.project, "--id", "feature", "--name", "verification", "--", process.execPath, "-e", "process.exit(99)"]), /cannot run arbitrary verification/);
-      } finally { if (old === undefined) delete process.env.CLAUDECODE; else process.env.CLAUDECODE = old; }
-      f.work(); f.review(); f.report();
-      assert.equal(close(f.project, "feature").phase, "DONE");
-      assert.equal(f.task().stages.implementation, undefined);
-      assert.ok(f.task().stages.analysis.evidence.path.startsWith(".nccgs/evidence/analysis/"));
-      f.write("Assets/game.cs", "// forbidden source edit\n");
-      assert.throws(() => close(f.project, "feature"), /modified source/);
-      f.report("blocked");
-      assert.equal(f.task().outcome, "blocked");
-      assert.throws(() => close(f.project, "feature"), /modified source/);
-      refreshInputs(f.project, "feature", "Recheck inputs without resetting source baseline");
-      assert.throws(() => check(f.project, f.task(), "analysis"), /modified source/);
-    } finally { f.dispose(); }
-  }
-});
-
-test("failed, blocked and partial reports are always writable without passing review or prerequisites", () => {
-  const f = fixture();
-  try {
-    for (const outcome of ["failed", "blocked", "partial"]) { f.report(outcome); assert.equal(f.task().stages.report.outcome, outcome); }
-    assert.equal(f.task().stages.report.verificationState.verified, false);
-    assert.throws(() => close(f.project, "feature"), /implementation: missing/);
-    f.work(); f.review({ verdict: "CHANGES_REQUIRED", criteriaMet: false, findings: [{ severity: "HIGH", status: "OPEN", description: "Fixture issue" }] });
-    const budget = f.task().reviewBudget.used;
-    f.report("blocked");
-    assert.equal(f.task().stages.review.findings[0].status, "OPEN");
-    assert.equal(f.task().reviewBudget.used, budget);
-    assert.throws(() => close(f.project, "feature"), /not passed/);
-    fs.unlinkSync(path.join(f.project, ".nccgs/intake.json"));
-    f.report("failed");
-    assert.equal(f.task().outcome, "failed");
-    const inspected = run(["inspect", "--project", f.project, "--id", "feature"]);
-    assert.equal(inspected.inputValidation.allowed, false);
-    assert.equal(inspected.task.outcome, "failed");
-    f.write(".nccgs/execution.json", { schemaVersion: 1, name: "standalone", externalReview: { mode: "required" } });
-    f.report("blocked");
-    assert.throws(() => close(f.project, "feature"), /Execution policy changed/);
-    f.write(".nccgs/execution.json", "malformed policy");
-    const failure = run(["report", "--project", f.project, "--id", "feature", "--outcome", "failed", "--summary", "Execution policy is unreadable; work cannot continue"]);
-    assert.equal(failure.outcome, "failed");
-    assert.equal(run(["inspect", "--project", f.project, "--id", "feature"]).inputValidation.allowed, false);
-  } finally { f.dispose(); }
-});
-
-test("standalone rejects wrong model and same reviewer identity; completed dispatch cannot be reused", () => {
-  const f = fixture();
-  try {
-    assert.throws(() => f.work({}, { observedModel: "claude-sonnet-4-6" }), /model\/fallback/);
-    f.work();
-    const implementation = f.task().stages.implementation;
-    assert.throws(() => record(f.project, "feature", "implementation", implementation), /only once/);
-    const trace = json(path.join(f.project, implementation.runtime.path));
-    assert.throws(() => f.review({}, { agentId: trace.agentId }), /independent/);
-    assert.equal(f.task().reviewBudget.used, 0);
-    f.review();
-    const reviewed = f.task().stages.review;
-    assert.throws(() => record(f.project, "feature", "review", reviewed), /only once/);
-    assert.equal(f.task().reviewBudget.used, 1);
-  } finally { f.dispose(); }
-});
-
-test("missing Claude Code provider/model and mandatory effort cannot become verified claims", () => {
-  const strict = fixture({ strictEffort: true });
-  const provider = fixture();
-  const model = fixture();
-  try {
-    assert.throws(() => strict.work({}, { observedEffort: null }), /effort is UNKNOWN/);
-    assert.equal(strict.task().stages.implementation, undefined);
-    assert.throws(() => provider.attempt("implementation", { observedProvider: null }), /observed Claude Code provider/);
-    assert.throws(() => model.attempt("implementation", { observedModel: null }), /Incomplete observed/);
-    strict.report("blocked"); provider.report("blocked"); model.report("blocked");
-    assert.equal(strict.task().outcome, "blocked");
-  } finally { strict.dispose(); provider.dispose(); model.dispose(); }
-});
-
-test("reclassification, input refresh and resume retain attempts, review budget and evidence history", () => {
-  const f = fixture({ contract: { objective: "Fix a local UI text", scope: "local", target: "fix" } });
-  try {
-    f.work(); f.review({ verdict: "CHANGES_REQUIRED", criteriaMet: false });
-    const original = f.task(), attempts = status(f.project, "feature").usage.dispatches;
-    reclassify(f.project, "feature", { risk: "CONTROLLED", reason: "Inspection found additional integration uncertainty", evidence: [{ observation: "Two interacting update paths found" }] });
-    assert.notEqual(f.task().contractHash, original.contractHash);
-    assert.equal(f.task().implementationRoute.effort, "high");
-    assert.equal(f.task().reviewBudget.used, 1);
-    assert.equal(f.task().reviewBudget.limit, 2);
-    assert.deepEqual(f.task().stages, {});
-    assert.ok(f.task().history.some(item => item.stages?.review?.verdict === "CHANGES_REQUIRED"));
-    f.write(".nccgs/requirements.yaml", "new requirement: preserve feedback timing\n");
-    assert.throws(() => check(f.project, f.task(), "implementation"), /Canonical inputs are stale/);
-    f.report("blocked");
-    refreshInputs(f.project, "feature", "Reconcile changed requirement source");
-    assert.equal(f.task().reviewBudget.used, 1);
-    assert.equal(f.task().reviewBudget.limit, 2);
-    assert.equal(f.task().risk, "CONTROLLED");
-    resume(f.project, "feature");
-    assert.equal(status(f.project, "feature").usage.dispatches, attempts);
-    assert.equal(f.task().reviewBudget.used, 1);
-  } finally { f.dispose(); }
-});
-
-test("contract source files and acceptance mappings stay enforced after intake normalization", () => {
-  const f = fixture();
-  try {
-    f.write(".nccgs/design.md", "Current damage feedback requirements");
-    f.write(".nccgs/intake.json", { ...f.contract, sources: [".nccgs/design.md"], acceptance: [{ id: "readability", description: "Player reads hit feedback", manual: true }, { id: "regression", description: "Old damage behavior preserved", check: "damage-regression" }] });
-    refreshInputs(f.project, "feature", "Include source and explicit acceptance mapping");
-    assert.ok(f.task().contract.requiredChecks.includes("damage-regression"));
-    assert.ok(f.task().contract.manualGates.includes("readability"));
-    f.write(".nccgs/design.md", "Changed requirements");
-    assert.throws(() => check(f.project, f.task(), "implementation"), /stale artifact/);
-    f.report("blocked");
-    assert.equal(f.task().stages.report.verificationState.verified, false);
-    f.write(".nccgs/invalid.json", { ...f.contract, acceptance: [{ id: "unmapped", description: "Cannot silently ignore" }] });
-    assert.throws(() => initialize(f.project, "bad-criteria", null, null, null, { contract: ".nccgs/invalid.json" }), /check name or manual/);
-  } finally { f.dispose(); }
-});
-
-test("manual acceptance gates require real external decision data only when declared", () => {
-  const f = fixture({ contract: { manualGates: ["playtest"] } });
-  try {
-    f.work(); f.review(); f.report();
-    assert.equal(check(f.project, f.task(), "acceptance").acceptanceRequired, true);
-    assert.throws(() => close(f.project, "feature"), /acceptance: missing/);
-    const approve = (overrides = {}) => record(f.project, "feature", "acceptance", { snapshot: f.snap(), evidence: f.write(`.nccgs/evidence/approval-${crypto.randomUUID()}.json`, { actor: "Product Owner", decision: "ACCEPTED", taskId: "feature", snapshot: f.snap(), contractHash: f.task().contractHash, decidedAt: new Date().toISOString(), statement: "Fixture explicit decision", reference: "fixture human decision", gates: [{ id: "playtest", decision: "ACCEPTED", reference: "fixture playtest" }], ...overrides }) });
-    assert.throws(() => approve({ actor: "Internal reviewer" }), /Product Owner/);
-    assert.throws(() => approve({ gates: [] }), /Manual gate missing/);
-    approve();
-    assert.equal(close(f.project, "feature").phase, "DONE");
-  } finally { f.dispose(); }
-});
-
-test("external off, advisory and required enforce distinct gates and retain findings", () => {
-  const off = fixture(), advisory = fixture({ external: "advisory" }), required = fixture({ external: "required" });
-  try {
-    assert.throws(() => importExternal(off.project, "feature", off.receipt()), /review is off/);
-    for (const f of [advisory, required]) { f.work(); f.review(); f.report(); }
-    const receipt = advisory.receipt({ verdict: "CHANGES_REQUIRED", findings: [{ severity: "HIGH", status: "OPEN", description: "Unconfirmed fixture concern" }] });
-    importExternal(advisory.project, "feature", receipt);
-    assert.equal(close(advisory.project, "feature").phase, "DONE");
-    assert.equal(check(advisory.project, advisory.task(), "done").externalReview.findings[0].status, "OPEN");
-    assert.throws(() => close(required.project, "feature"), /Required external review is missing/);
-    const exported = exportExternal(required.project, "feature", ".nccgs/evidence/external/requests/request.json");
-    assert.equal(json(path.join(required.project, exported.path)).contractHash, required.task().contractHash);
-    assert.throws(() => exportExternal(required.project, "feature", exported.path), /EEXIST/);
-    assert.throws(() => exportExternal(required.project, "feature", required.task().stages.implementation.runtime.path), /external\/requests/);
-    const blockedReceipt = required.receipt({ verdict: "BLOCKED", findings: [{ severity: "HIGH", status: "OPEN", description: "Must resolve fixture risk" }] });
-    importExternal(required.project, "feature", blockedReceipt);
-    assert.throws(() => close(required.project, "feature"), /has not passed/);
-    importExternal(required.project, "feature", required.receipt());
-    assert.throws(() => close(required.project, "feature"), /explicit supersession/);
-    importExternal(required.project, "feature", required.receipt({ supersedes: [json(path.join(required.project, blockedReceipt)).id], supersessionReason: "External reviewer verified the prior issue is resolved; fixture source report" }));
-    assert.equal(close(required.project, "feature").phase, "DONE");
-    assert.ok(check(required.project, required.task(), "done").externalReview.findings[0].supersededBy);
-  } finally { off.dispose(); advisory.dispose(); required.dispose(); }
-});
-
-test("external receipts reject stale contracts, stale snapshots and duplicate IDs with different content", () => {
-  const f = fixture({ external: "required" });
-  try {
-    const stale = f.receipt();
-    reclassify(f.project, "feature", { risk: "CONTROLLED", reason: "Additional risk found", evidence: ["fixture inspection source"] });
-    assert.throws(() => importExternal(f.project, "feature", stale), /stale/);
-    assert.throws(() => importExternal(f.project, "feature", f.receipt({ snapshot: "different" })), /stale/);
-    assert.throws(() => importExternal(f.project, "feature", f.receipt({ findings: [{}] })), /malformed findings/);
-    const current = f.receipt({ id: "external-123" });
-    importExternal(f.project, "feature", current);
-    importExternal(f.project, "feature", current);
-    assert.equal(f.task().externalReviews.length, 1);
-    assert.throws(() => importExternal(f.project, "feature", f.receipt({ id: "external-123", verdict: "BLOCKED" })), /different content/);
-    const old = process.env.CLAUDECODE;
-    try { process.env.CLAUDECODE = "1"; assert.throws(() => importExternal(f.project, "feature", current), /outside the Claude session/); }
-    finally { if (old === undefined) delete process.env.CLAUDECODE; else process.env.CLAUDECODE = old; }
-  } finally { f.dispose(); }
-});
-
-test("partial reports and missing required closure artifacts never unlock DONE", () => {
-  const f = fixture({ contract: { requiredArtifacts: [".nccgs/evidence/build.txt"] } });
-  try {
-    f.work(); f.review(); f.report("partial");
-    assert.throws(() => close(f.project, "feature"), /not success/);
-    f.report("success");
-    assert.throws(() => close(f.project, "feature"), /closure artifact missing/);
-    f.report("blocked");
-    f.report("success", { artifacts: [f.write(".nccgs/evidence/build.txt", "fixture build artifact")] });
-    assert.equal(close(f.project, "feature").phase, "DONE");
-    f.write(".nccgs/evidence/build.txt", "changed artifact");
-    assert.throws(() => close(f.project, "feature"), /stale artifact/);
-  } finally { f.dispose(); }
-});
+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 { fileURLToPath } from "node:url";
+import test from "node:test";
+import { artifact, atomicJson, json } from "../.claude/nccgs/tools/policy.mjs";
+import { initialize, snapshot, record, check, close, taskPath, reclassify, refreshInputs, importExternal, exportExternal, extendReview } from "../.claude/nccgs/tools/gates.mjs";
+import { reserve, claim, complete, status, resume } from "../.claude/nccgs/tools/orchestration.mjs";
+import { run } from "../.claude/nccgs/tools/task.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+// All provider observations below are synthetic fixtures. They verify framework
+// evidence mechanics, not actual Claude Code/model execution or game quality.
+function fixture(options = {}) {
+  const project = fs.mkdtempSync(path.join(os.tmpdir(), "nccgs-lifecycle-v15-"));
+  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);
+  };
+  for (const name of ["pipeline.json", "studio.json"]) write(`.claude/nccgs/${name}`, fs.readFileSync(path.join(root, ".claude/nccgs", name), "utf8"));
+  write(".nccgs/project.yaml", "schema_version: 2\nmodels:\n  profile: claude-standalone\n");
+  write(".nccgs/execution.json", { schemaVersion: 1, name: "standalone", externalReview: { mode: options.external || "off" }, acceptanceRequired: options.acceptance || false, requireObservedEffort: options.strictEffort || false });
+  write("Assets/game.cs", "// source baseline\n");
+  const contract = { schemaVersion: 1, objective: "Implement a bounded enemy feedback feature", mode: options.mode || "implement", scope: "feature", target: "production-change", readiness: "ready", requiredChecks: ["verification"], ...options.contract };
+  write(".nccgs/intake.json", contract);
+  initialize(project, "feature", null, null, null, { intake: ".nccgs/intake.json" });
+  let index = 0;
+  const task = () => json(taskPath(project, "feature"));
+  const snap = () => snapshot(project, task()).sha256;
+  function attempt(kind, rawOverrides = {}) {
+    const current = task(), count = ++index, agent = kind === "review" ? "nccgs-adversarial-reviewer" : kind === "analysis" ? "nccgs-task-scout" : current.implementationRoute.class === "deep" ? "nccgs-unity-implementer" : "nccgs-gameplay-programmer";
+    const d = reserve(project, "feature", { kind, agent, requestKey: `request-${count}`, reason: `Synthetic fixture ${kind}`, writePaths: kind === "implementation" ? ["Assets/game.cs"] : [], limits: { maxDispatches: 100 } });
+    claim(project, d.id, { sessionId: "fixture-session", toolUseId: `tool-${count}`, agent });
+    const route = kind === "review" ? current.execution.profile.models.review : current.implementationRoute;
+    const model = route.model === "sonnet" ? "claude-sonnet-4-6" : route.model === "opus" ? "claude-opus-5-5" : route.model === "fable" ? "claude-fable-5-1" : route.model;
+    const source = `.nccgs/evidence/raw-${count}.json`;
+    write(source, { taskId: "feature", 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: model, observedEffort: options.strictEffort ? route.effort : null,
+      provenance: { kind: "provider-log", reference: "SYNTHETIC TEST FIXTURE, not actual Claude Code execution" }, ...rawOverrides });
+    const runtime = run(["observe", "--project", project, "--id", "feature", "--file", source]);
+    complete(project, d.id, { runtime });
+    return { snapshot: snap(), dispatchId: d.id, runtime };
+  }
+  function work(overrides = {}, raw = {}) {
+    const name = task().mode === "implement" ? "implementation" : "analysis";
+    const input = { ...attempt(name, raw), checks: [{ name: "verification", status: "PASS", evidence: write(`.nccgs/evidence/check-${++index}.md`, "Fixture source reasoning / acceptance verification: PASS") }], ...overrides };
+    if (name === "analysis" && !input.evidence) input.evidence = write(task().contract.analysisArtifacts[0], "# Fixture analysis\n\nSource observations and recommendations.");
+    return record(project, "feature", name, input);
+  }
+  const review = (overrides = {}, raw = {}) => record(project, "feature", "review", { ...attempt("review", raw), verdict: "PASS", criteriaMet: true, findings: [], evidence: write(`.nccgs/evidence/review-${++index}.md`, "Fixture independent review: no open findings"), ...overrides });
+  const report = (outcome = "success", overrides = {}) => record(project, "feature", "report", { outcome, summary: `Fixture ${outcome} report. No real model/game execution claimed.`, ...overrides });
+  function receipt(overrides = {}) {
+    const relative = `.nccgs/evidence/receipt-${++index}.json`;
+    write(relative, { schemaVersion: 1, id: `receipt-${index}`, taskId: "feature", contractHash: task().contractHash, snapshot: snap(), actor: "External fixture reviewer", verdict: "PASS", findings: [], reviewedAt: new Date().toISOString(), source: "fixture external review event", ...overrides });
+    return relative;
+  }
+  return { project, contract, write, task, snap, attempt, work, review, report, receipt,
+    dispose() { const resolved = path.resolve(project); assert.ok(resolved.startsWith(path.resolve(os.tmpdir()) + path.sep + "nccgs-lifecycle-v15-")); fs.rmSync(resolved, { recursive: true, force: true }); } };
+}
+
+test("standalone finishes without Astra or acceptance while preserving UNKNOWN effort", () => {
+  const f = fixture();
+  try {
+    assert.equal(f.task().schemaVersion, 2);
+    assert.equal(f.task().risk, "STANDARD");
+    assert.equal(f.task().implementationRoute.model, "opus");
+    assert.throws(() => close(f.project, "feature"), /implementation: missing/);
+    f.work(); f.review(); f.report();
+    const result = close(f.project, "feature");
+    assert.equal(result.phase, "DONE");
+    assert.equal(result.acceptanceRequired, false);
+    assert.equal(result.executionEvidence.effortEvidence, "UNKNOWN");
+    assert.equal(result.executionEvidence.observedEffort, null);
+    assert.deepEqual(Object.keys(f.task().stages), ["implementation", "review", "report"]);
+  } finally { f.dispose(); }
+});
+
+test("classifier uses concrete signals, rejects unsafe overrides and supports direct text intake", () => {
+  const fast = fixture({ contract: { objective: "Fix one UI label alignment", scope: "local", target: "fix" } });
+  const controlled = fixture({ contract: { objective: "Migrate the save serialization format", scope: "local" } });
+  try {
+    assert.equal(fast.task().risk, "FAST");
+    assert.equal(fast.task().implementationRoute.model, "sonnet");
+    assert.ok(fast.task().classification.evidence.length);
+    assert.equal(controlled.task().risk, "CONTROLLED");
+    assert.match(controlled.task().classification.reason, /save\/serialization|migration/);
+    assert.throws(() => reclassify(controlled.project, "feature", { risk: "FAST", reason: "Only one file", evidence: ["One file changed"] }), /require CONTROLLED/);
+    fast.write(".nccgs/request.md", "Review feasibility of the enemy feedback design. Produce a plan only.");
+    const planned = run(["init", "--project", fast.project, "--id", "direct-plan", "--intake", ".nccgs/request.md", "--mode", "plan"]);
+    assert.equal(planned.mode, "plan");
+    assert.equal(planned.risk, "STANDARD");
+    assert.deepEqual(planned.contract.analysisArtifacts, [".nccgs/evidence/analysis/direct-plan-result.md"]);
+    assert.throws(() => initialize(fast.project, "bad", null, null, "FAST", { intake: ".nccgs/intake.json" }), /classification reason/);
+    assert.throws(() => initialize(fast.project, "incomplete", null, null, "FAST", { intake: ".nccgs/request.md", reason: "Assumed small" }), /ready local fix/);
+  } finally { fast.dispose(); controlled.dispose(); }
+});
+
+test("audit and plan use analysis evidence and fail if source changes", () => {
+  for (const mode of ["audit", "plan"]) {
+    const f = fixture({ mode });
+    try {
+      assert.throws(() => reserve(f.project, "feature", { kind: "implementation", agent: "nccgs-gameplay-programmer", requestKey: "bad", reason: "Wrong mode", writePaths: ["Assets/game.cs"] }), /cannot dispatch implementation/);
+      const old = process.env.CLAUDECODE;
+      try {
+        process.env.CLAUDECODE = "1";
+        assert.throws(() => run(["verify", "--project", f.project, "--id", "feature", "--name", "verification", "--", process.execPath, "-e", "process.exit(99)"]), /cannot run arbitrary verification/);
+      } finally { if (old === undefined) delete process.env.CLAUDECODE; else process.env.CLAUDECODE = old; }
+      f.work(); f.review(); f.report();
+      assert.equal(close(f.project, "feature").phase, "DONE");
+      assert.equal(f.task().stages.implementation, undefined);
+      assert.ok(f.task().stages.analysis.evidence.path.startsWith(".nccgs/evidence/analysis/"));
+      f.write("Assets/game.cs", "// forbidden source edit\n");
+      assert.throws(() => close(f.project, "feature"), /modified source/);
+      f.report("blocked");
+      assert.equal(f.task().outcome, "blocked");
+      assert.throws(() => close(f.project, "feature"), /modified source/);
+      refreshInputs(f.project, "feature", "Recheck inputs without resetting source baseline");
+      assert.throws(() => check(f.project, f.task(), "analysis"), /modified source/);
+    } finally { f.dispose(); }
+  }
+});
+
+test("failed, blocked and partial reports are always writable without passing review or prerequisites", () => {
+  const f = fixture();
+  try {
+    for (const outcome of ["failed", "blocked", "partial"]) { f.report(outcome); assert.equal(f.task().stages.report.outcome, outcome); }
+    assert.equal(f.task().stages.report.verificationState.verified, false);
+    assert.throws(() => close(f.project, "feature"), /implementation: missing/);
+    f.work(); f.review({ verdict: "CHANGES_REQUIRED", criteriaMet: false, findings: [{ severity: "HIGH", status: "OPEN", description: "Fixture issue" }] });
+    const budget = f.task().reviewBudget.used;
+    f.report("blocked");
+    assert.equal(f.task().stages.review.findings[0].status, "OPEN");
+    assert.equal(f.task().reviewBudget.used, budget);
+    assert.throws(() => close(f.project, "feature"), /not passed/);
+    fs.unlinkSync(path.join(f.project, ".nccgs/intake.json"));
+    f.report("failed");
+    assert.equal(f.task().outcome, "failed");
+    const inspected = run(["inspect", "--project", f.project, "--id", "feature"]);
+    assert.equal(inspected.inputValidation.allowed, false);
+    assert.equal(inspected.task.outcome, "failed");
+    f.write(".nccgs/execution.json", { schemaVersion: 1, name: "standalone", externalReview: { mode: "required" } });
+    f.report("blocked");
+    assert.throws(() => close(f.project, "feature"), /Execution policy changed/);
+    f.write(".nccgs/execution.json", "malformed policy");
+    const failure = run(["report", "--project", f.project, "--id", "feature", "--outcome", "failed", "--summary", "Execution policy is unreadable; work cannot continue"]);
+    assert.equal(failure.outcome, "failed");
+    assert.equal(run(["inspect", "--project", f.project, "--id", "feature"]).inputValidation.allowed, false);
+  } finally { f.dispose(); }
+});
+
+test("standalone rejects wrong model and same reviewer identity; completed dispatch cannot be reused", () => {
+  const f = fixture();
+  try {
+    assert.throws(() => f.work({}, { observedModel: "claude-sonnet-4-6" }), /model\/fallback/);
+    f.work();
+    const implementation = f.task().stages.implementation;
+    assert.throws(() => record(f.project, "feature", "implementation", implementation), /only once/);
+    const trace = json(path.join(f.project, implementation.runtime.path));
+    assert.throws(() => f.review({}, { agentId: trace.agentId }), /independent/);
+    assert.equal(f.task().reviewBudget.used, 0);
+    f.review();
+    const reviewed = f.task().stages.review;
+    assert.throws(() => record(f.project, "feature", "review", reviewed), /only once/);
+    assert.equal(f.task().reviewBudget.used, 1);
+  } finally { f.dispose(); }
+});
+
+test("missing Claude Code provider/model and mandatory effort cannot become verified claims", () => {
+  const strict = fixture({ strictEffort: true });
+  const provider = fixture();
+  const model = fixture();
+  try {
+    assert.throws(() => strict.work({}, { observedEffort: null }), /effort is UNKNOWN/);
+    assert.equal(strict.task().stages.implementation, undefined);
+    assert.throws(() => provider.attempt("implementation", { observedProvider: null }), /observed Claude Code provider/);
+    assert.throws(() => model.attempt("implementation", { observedModel: null }), /Incomplete observed/);
+    strict.report("blocked"); provider.report("blocked"); model.report("blocked");
+    assert.equal(strict.task().outcome, "blocked");
+  } finally { strict.dispose(); provider.dispose(); model.dispose(); }
+});
+
+test("reclassification, input refresh and resume retain attempts, review budget and evidence history", () => {
+  const f = fixture({ contract: { objective: "Fix a local UI text", scope: "local", target: "fix" } });
+  try {
+    f.work(); f.review({ verdict: "CHANGES_REQUIRED", criteriaMet: false });
+    const original = f.task(), attempts = status(f.project, "feature").usage.dispatches;
+    reclassify(f.project, "feature", { risk: "CONTROLLED", reason: "Inspection found additional integration uncertainty", evidence: [{ observation: "Two interacting update paths found" }] });
+    assert.notEqual(f.task().contractHash, original.contractHash);
+    assert.equal(f.task().implementationRoute.effort, "xhigh");
+    assert.equal(f.task().reviewBudget.used, 1);
+    assert.equal(f.task().reviewBudget.limit, 2);
+    assert.deepEqual(f.task().stages, {});
+    assert.ok(f.task().history.some(item => item.stages?.review?.verdict === "CHANGES_REQUIRED"));
+    f.write(".nccgs/requirements.yaml", "new requirement: preserve feedback timing\n");
+    assert.throws(() => check(f.project, f.task(), "implementation"), /Canonical inputs are stale/);
+    f.report("blocked");
+    refreshInputs(f.project, "feature", "Reconcile changed requirement source");
+    assert.equal(f.task().reviewBudget.used, 1);
+    assert.equal(f.task().reviewBudget.limit, 2);
+    assert.equal(f.task().risk, "CONTROLLED");
+    resume(f.project, "feature");
+    assert.equal(status(f.project, "feature").usage.dispatches, attempts);
+    assert.equal(f.task().reviewBudget.used, 1);
+  } finally { f.dispose(); }
+});
+
+test("contract source files and acceptance mappings stay enforced after intake normalization", () => {
+  const f = fixture();
+  try {
+    f.write(".nccgs/design.md", "Current damage feedback requirements");
+    f.write(".nccgs/intake.json", { ...f.contract, sources: [".nccgs/design.md"], acceptance: [{ id: "readability", description: "Player reads hit feedback", manual: true }, { id: "regression", description: "Old damage behavior preserved", check: "damage-regression" }] });
+    refreshInputs(f.project, "feature", "Include source and explicit acceptance mapping");
+    assert.ok(f.task().contract.requiredChecks.includes("damage-regression"));
+    assert.ok(f.task().contract.manualGates.includes("readability"));
+    f.write(".nccgs/design.md", "Changed requirements");
+    assert.throws(() => check(f.project, f.task(), "implementation"), /stale artifact/);
+    f.report("blocked");
+    assert.equal(f.task().stages.report.verificationState.verified, false);
+    f.write(".nccgs/invalid.json", { ...f.contract, acceptance: [{ id: "unmapped", description: "Cannot silently ignore" }] });
+    assert.throws(() => initialize(f.project, "bad-criteria", null, null, null, { contract: ".nccgs/invalid.json" }), /check name or manual/);
+  } finally { f.dispose(); }
+});
+
+test("manual acceptance gates require real external decision data only when declared", () => {
+  const f = fixture({ contract: { manualGates: ["playtest"] } });
+  try {
+    f.work(); f.review(); f.report();
+    assert.equal(check(f.project, f.task(), "acceptance").acceptanceRequired, true);
+    assert.throws(() => close(f.project, "feature"), /acceptance: missing/);
+    const approve = (overrides = {}) => record(f.project, "feature", "acceptance", { snapshot: f.snap(), evidence: f.write(`.nccgs/evidence/approval-${crypto.randomUUID()}.json`, { actor: "Product Owner", decision: "ACCEPTED", taskId: "feature", snapshot: f.snap(), contractHash: f.task().contractHash, decidedAt: new Date().toISOString(), statement: "Fixture explicit decision", reference: "fixture human decision", gates: [{ id: "playtest", decision: "ACCEPTED", reference: "fixture playtest" }], ...overrides }) });
+    assert.throws(() => approve({ actor: "Internal reviewer" }), /Product Owner/);
+    assert.throws(() => approve({ gates: [] }), /Manual gate missing/);
+    approve();
+    assert.equal(close(f.project, "feature").phase, "DONE");
+  } finally { f.dispose(); }
+});
+
+test("external off, advisory and required enforce distinct gates and retain findings", () => {
+  const off = fixture(), advisory = fixture({ external: "advisory" }), required = fixture({ external: "required" });
+  try {
+    assert.throws(() => importExternal(off.project, "feature", off.receipt()), /review is off/);
+    for (const f of [advisory, required]) { f.work(); f.review(); f.report(); }
+    const receipt = advisory.receipt({ verdict: "CHANGES_REQUIRED", findings: [{ severity: "HIGH", status: "OPEN", description: "Unconfirmed fixture concern" }] });
+    importExternal(advisory.project, "feature", receipt);
+    assert.equal(close(advisory.project, "feature").phase, "DONE");
+    assert.equal(check(advisory.project, advisory.task(), "done").externalReview.findings[0].status, "OPEN");
+    assert.throws(() => close(required.project, "feature"), /Required external review is missing/);
+    const exported = exportExternal(required.project, "feature", ".nccgs/evidence/external/requests/request.json");
+    assert.equal(json(path.join(required.project, exported.path)).contractHash, required.task().contractHash);
+    assert.throws(() => exportExternal(required.project, "feature", exported.path), /EEXIST/);
+    assert.throws(() => exportExternal(required.project, "feature", required.task().stages.implementation.runtime.path), /external\/requests/);
+    const blockedReceipt = required.receipt({ verdict: "BLOCKED", findings: [{ severity: "HIGH", status: "OPEN", description: "Must resolve fixture risk" }] });
+    importExternal(required.project, "feature", blockedReceipt);
+    assert.throws(() => close(required.project, "feature"), /has not passed/);
+    importExternal(required.project, "feature", required.receipt());
+    assert.throws(() => close(required.project, "feature"), /explicit supersession/);
+    importExternal(required.project, "feature", required.receipt({ supersedes: [json(path.join(required.project, blockedReceipt)).id], supersessionReason: "External reviewer verified the prior issue is resolved; fixture source report" }));
+    assert.equal(close(required.project, "feature").phase, "DONE");
+    assert.ok(check(required.project, required.task(), "done").externalReview.findings[0].supersededBy);
+  } finally { off.dispose(); advisory.dispose(); required.dispose(); }
+});
+
+test("external receipts reject stale contracts, stale snapshots and duplicate IDs with different content", () => {
+  const f = fixture({ external: "required" });
+  try {
+    const stale = f.receipt();
+    reclassify(f.project, "feature", { risk: "CONTROLLED", reason: "Additional risk found", evidence: ["fixture inspection source"] });
+    assert.throws(() => importExternal(f.project, "feature", stale), /stale/);
+    assert.throws(() => importExternal(f.project, "feature", f.receipt({ snapshot: "different" })), /stale/);
+    assert.throws(() => importExternal(f.project, "feature", f.receipt({ findings: [{}] })), /malformed findings/);
+    const current = f.receipt({ id: "external-123" });
+    importExternal(f.project, "feature", current);
+    importExternal(f.project, "feature", current);
+    assert.equal(f.task().externalReviews.length, 1);
+    assert.throws(() => importExternal(f.project, "feature", f.receipt({ id: "external-123", verdict: "BLOCKED" })), /different content/);
+    const old = process.env.CLAUDECODE;
+    try { process.env.CLAUDECODE = "1"; assert.throws(() => importExternal(f.project, "feature", current), /outside the Claude session/); }
+    finally { if (old === undefined) delete process.env.CLAUDECODE; else process.env.CLAUDECODE = old; }
+  } finally { f.dispose(); }
+});
+
+test("partial reports and missing required closure artifacts never unlock DONE", () => {
+  const f = fixture({ contract: { requiredArtifacts: [".nccgs/evidence/build.txt"] } });
+  try {
+    f.work(); f.review(); f.report("partial");
+    assert.throws(() => close(f.project, "feature"), /not success/);
+    f.report("success");
+    assert.throws(() => close(f.project, "feature"), /closure artifact missing/);
+    f.report("blocked");
+    f.report("success", { artifacts: [f.write(".nccgs/evidence/build.txt", "fixture build artifact")] });
+    assert.equal(close(f.project, "feature").phase, "DONE");
+    f.write(".nccgs/evidence/build.txt", "changed artifact");
+    assert.throws(() => close(f.project, "feature"), /stale artifact/);
+  } finally { f.dispose(); }
+});
+
+// Explicit observed-effort boundaries, using synthetic correlated provider-log fixtures.
+// These cases never establish actual native model/effort execution.
+test("CONTROLLED accepts observed xhigh and its independent Fable high review", () => {
+  const f = fixture({ strictEffort: true, contract: { objective: "Migrate the save serialization format", scope: "local" } });
+  try {
+    assert.equal(f.task().risk, "CONTROLLED");
+    assert.equal(f.task().implementationRoute.effort, "xhigh");
+    f.work();
+    const work = json(path.join(f.project, f.task().stages.implementation.runtime.path));
+    assert.equal(work.observedEffort, "xhigh");
+    f.review();
+    const review = json(path.join(f.project, f.task().stages.review.runtime.path));
+    assert.equal(review.observedModel, "claude-fable-5-1");
+    assert.equal(f.task().execution.profile.models.review.effort, "high");
+    assert.equal(review.observedEffort, "high");
+  } finally { f.dispose(); }
+});
+
+test("CONTROLLED rejects observed high when xhigh was selected and retains its dispatch", () => {
+  const f = fixture({ strictEffort: true, contract: { objective: "Migrate the save serialization format", scope: "local" } });
+  try {
+    assert.throws(() => f.work({}, { observedEffort: "high" }), /Observed effort does not match selected route/);
+    assert.equal(f.task().stages.implementation, undefined);
+    assert.equal(status(f.project, "feature").usage.dispatches, 1);
+  } finally { f.dispose(); }
+});
+
+test("CONTROLLED does not infer observed xhigh from its configured route", () => {
+  const f = fixture({ strictEffort: true, contract: { objective: "Migrate the save serialization format", scope: "local" } });
+  try {
+    assert.throws(() => f.work({}, { observedEffort: null }), /effort is UNKNOWN/);
+    assert.equal(f.task().stages.implementation, undefined);
+    assert.equal(status(f.project, "feature").usage.dispatches, 1);
+  } finally { f.dispose(); }
+});
+
+test("Fable review rejects observed xhigh when high was selected without approving the task", () => {
+  const f = fixture({ strictEffort: true, contract: { objective: "Migrate the save serialization format", scope: "local" } });
+  try {
+    f.work();
+    assert.throws(() => f.review({}, { observedEffort: "xhigh" }), /Observed effort does not match selected route/);
+    assert.equal(f.task().stages.review, undefined); assert.equal(f.task().reviewBudget.used, 0);
+    assert.equal(status(f.project, "feature").usage.dispatches, 2);
+  } finally { f.dispose(); }
+});