nccgs 2.0.0-rc.2 → 2.0.0

package/tests/review-budget.test.mjs

@@ -0,0 +1,177 @@
+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 test from "node:test";
+import { artifact, atomicJson } from "../.claude/nccgs/tools/policy.mjs";
+import { acquireLock } from "../.claude/nccgs/tools/process-lock.mjs";
+import { sessionBudgetLock } from "../.claude/nccgs/tools/session-budget.mjs";
+import { allocateReviewBudget, findReviewBudget, plannedDispatchBudget, registerReviewBudget, reviewBudgetStatus } from "../.claude/nccgs/tools/review-budget.mjs";
+
+// Synthetic accounting fixtures, never provider/game qualification evidence.
+function fixture() {
+  const temp = fs.realpathSync(os.tmpdir()), project = fs.mkdtempSync(path.join(temp, "nccgs-review-reserve-"));
+  const write = (file, value) => atomicJson(path.join(project, file), value);
+  write('.nccgs/tasks/root.json', { id: 'root', schemaVersion: 2, mode: 'plan', parentId: null });
+  for (const id of ['delivery', 'sibling']) write(`.nccgs/tasks/${id}.json`, { id, schemaVersion: 2, mode: 'implement', parentId: 'root' });
+  const request = '.nccgs/evidence/reserve.json';
+  write(request, { schemaVersion: 1, authority: 'Synthetic external test allocation', totalUsd: 12, finalReviewUsd: 4, totalDurationMs: 4500000, finalReviewDurationMs: 900000 });
+  const plan = () => registerReviewBudget(project, 'root', request);
+  const save = run => write(`.nccgs/runs/${run.id}/run.json`, run);
+  const run = (taskId = 'root', requested = 12) => {
+    const state = { schemaVersion: 1, id: crypto.randomUUID(), project, taskId, sessionId: crypto.randomUUID(), budgetUsd: requested,
+      deadline: Date.now() + 4500000, status: 'ready', costCoverage: 'complete', cumulativeCostUsd: 0, invocations: [] }; save(state); return state;
+  };
+  const locked = (state, action) => { const lock = acquireLock(path.join(project, sessionBudgetLock), { runId: state.id, sessionId: state.sessionId }); try { return action(); } finally { lock.release(); } };
+  const allocate = (state, phase = 'work') => locked(state, () => { const result = allocateReviewBudget(project, state, phase); save(state); return result; });
+  const finish = (state, cost) => {
+    const log = `native-${state.invocations.length}.jsonl`, file = `.nccgs/runs/${state.id}/${log}`;
+    fs.writeFileSync(path.join(project, file), JSON.stringify({ type: 'result', session_id: state.sessionId, total_cost_usd: cost }) + '\n');
+    state.invocations.push({ status: 'finished', log, evidence: artifact(project, file) });
+    Object.assign(state, { status: 'settled', costCoverage: 'complete', cumulativeCostUsd: cost }); save(state);
+  };
+  return { project, write, request, plan, run, save, locked, allocate, finish, dispose() {
+    assert.equal(path.dirname(project), temp); assert.ok(path.basename(project).startsWith('nccgs-review-reserve-'));
+    assert.equal(fs.realpathSync(project), project); fs.rmSync(project, { recursive: true, force: true });
+  } };
+}
+
+test('adopting a legacy task cannot ignore a started worker session when maxCostUsd was omitted', () => {
+  const f = fixture(); try {
+    f.write('.nccgs/orchestration.json', { tasks: { root: { limits: { maxCostUsd: null } } }, dispatches: {
+      old: { taskId: 'delivery', sessionId: 'uncovered-old-session', startedAt: new Date().toISOString(), status: 'completed', telemetry: { costUsd: null } }
+    } });
+    assert.throws(() => f.plan(), /worker session.*supervised cost coverage/);
+    assert.equal(fs.existsSync(path.join(f.project, '.nccgs/budgets/root.initialized.json')), false);
+  } finally { f.dispose(); }
+});
+
+test('a reserve refuses unexplained historical workers before allocating another session', () => {
+  const f = fixture(); try {
+    f.plan(); const old = f.run(); f.allocate(old); f.finish(old, 2);
+    f.write('.nccgs/orchestration.json', { tasks: { root: { limits: { maxCostUsd: null } } }, dispatches: {
+      known: { taskId: 'root', sessionId: old.sessionId, startedAt: new Date().toISOString(), status: 'completed' },
+      unknown: { taskId: 'delivery', sessionId: 'missing-old-session', startedAt: new Date().toISOString(), status: 'completed' }
+    } });
+    const next = f.run('delivery');
+    assert.throws(() => f.allocate(next), /worker session.*supervised cost coverage/);
+    assert.equal(next.budgetAllocation, undefined);
+  } finally { f.dispose(); }
+});
+test('budget terms are pinned externally and children cannot create new money', () => {
+  const f = fixture(); try {
+    const first = f.plan(); assert.deepEqual(f.plan(), first);
+    assert.equal(findReviewBudget(f.project, 'delivery').taskId, 'root');
+    assert.throws(() => registerReviewBudget(f.project, 'delivery', f.request), /already pinned/);
+    f.write('.nccgs/evidence/replacement.json', { schemaVersion: 1, authority: 'changed', totalUsd: 20, finalReviewUsd: 4 });
+    assert.throws(() => registerReviewBudget(f.project, 'root', '.nccgs/evidence/replacement.json'), /already pinned/);
+    f.write('.nccgs/budgets/root.json', { ...first, limits: { ...first.limits, totalUsd: 20 } });
+    assert.throws(() => findReviewBudget(f.project, 'root'), /pinned budget terms/);
+  } finally { f.dispose(); }
+});
+test('successive design/delivery sessions share eight dollars while four and fifteen minutes stay protected', () => {
+  const f = fixture(); try {
+    const plan = f.plan(), design = f.run(); f.allocate(design);
+    assert.equal(design.budgetUsd, 8); assert.equal(design.deadline, plan.deadline - 900000);
+    f.finish(design, 4.5);
+    const delivery = f.run('delivery'); f.allocate(delivery); assert.equal(delivery.budgetUsd, 3.5); f.finish(delivery, 3.5);
+    const review = f.run('delivery'); f.allocate(review, 'final-review'); assert.equal(review.budgetUsd, 4); assert.equal(review.deadline, plan.deadline); f.finish(review, 2.25);
+    const status = reviewBudgetStatus(f.project, 'root'); assert.equal(status.settledCostUsd, 10.25); assert.equal(status.protectedReviewUsd, 1.75);
+    const repair = f.run('sibling'); assert.throws(() => f.allocate(repair), /exhausted/);
+  } finally { f.dispose(); }
+});
+test('review may use unused work funds, but spent review money cannot be refunded to a later repair', () => {
+  const f = fixture(); try {
+    f.plan(); const work = f.run('delivery'); f.allocate(work); f.finish(work, 6);
+    const review = f.run('delivery'); f.allocate(review, 'final-review'); assert.equal(review.budgetUsd, 6); f.finish(review, 5);
+    const repair = f.run('delivery'); f.allocate(repair); assert.equal(repair.budgetUsd, 1);
+  } finally { f.dispose(); }
+});
+test('missing native usage or an allocated run blocks further spending, even when workers supplied no cost', () => {
+  const f = fixture(); try {
+    f.plan(); const old = f.run(); f.allocate(old); f.finish(old, 2);
+    const next = f.run('delivery'); old.costCoverage = 'unknown-current-invocation'; f.save(old);
+    assert.throws(() => f.allocate(next), /unknown/); old.costCoverage = 'complete'; f.save(old);
+    fs.renameSync(path.join(f.project, `.nccgs/runs/${old.id}/run.json`), path.join(f.project, `.nccgs/runs/${old.id}/missing.json`));
+    assert.throws(() => f.allocate(next), /ENOENT|missing/);
+  } finally { f.dispose(); }
+});
+test('recovery retains the original allocation and cumulative resumed totals are never added twice', () => {
+  const f = fixture(); try {
+    f.plan(); const first = f.run(); f.allocate(first); f.finish(first, 1); f.finish(first, 2);
+    f.allocate(first); assert.equal(first.budgetUsd, 8);
+    first.budgetUsd = 12; assert.throws(() => f.allocate(first), /recovery cannot alter/); first.budgetUsd = 8;
+    const next = f.run('delivery'); f.allocate(next); assert.equal(next.budgetUsd, 6);
+    assert.throws(() => f.allocate(next, 'final-review'), /recovery cannot alter/);
+  } finally { f.dispose(); }
+});
+test('live work/review dispatch admissions enforce phase and keep final delivery review independent', () => {
+  const f = fixture(), names = ['NCCGS_SUPERVISED_RUN', 'NCCGS_SUPERVISED_SESSION'], saved = names.map(n => process.env[n]);
+  try {
+    f.plan(); const work = f.run('delivery'); f.allocate(work);
+    Object.assign(work, { status: 'running', invocations: [{ status: 'running', pid: process.pid }] }); f.save(work);
+    process.env.NCCGS_SUPERVISED_RUN = work.id; process.env.NCCGS_SUPERVISED_SESSION = work.sessionId;
+    f.locked(work, () => {
+      assert.equal(plannedDispatchBudget(f.project, 'delivery', { kind: 'implementation' }).phase, 'work');
+      assert.throws(() => plannedDispatchBudget(f.project, 'delivery', { kind: 'review' }), /protected final-review/);
+    });
+    work.invocations = []; f.finish(work, 2);
+    const review = f.run('delivery'); f.allocate(review, 'final-review');
+    Object.assign(review, { status: 'running', invocations: [{ status: 'running', pid: process.pid }] }); f.save(review);
+    process.env.NCCGS_SUPERVISED_RUN = review.id; process.env.NCCGS_SUPERVISED_SESSION = review.sessionId;
+    f.locked(review, () => {
+      assert.equal(plannedDispatchBudget(f.project, 'delivery', { kind: 'review' }).phase, 'final-review');
+      for (const kind of ['analysis', 'implementation']) assert.throws(() => plannedDispatchBudget(f.project, 'delivery', { kind }), /cannot dispatch/);
+    });
+  } finally { names.forEach((n,i) => { if(saved[i]===undefined) delete process.env[n]; else process.env[n]=saved[i]; }); f.dispose(); }
+});
+test('audit protects independent final review and never spends its reserve on another analysis', () => {
+  const f = fixture(), names = ['NCCGS_SUPERVISED_RUN', 'NCCGS_SUPERVISED_SESSION'], saved = names.map(n => process.env[n]);
+  try {
+    f.write('.nccgs/tasks/root.json', { id: 'root', schemaVersion: 2, mode: 'audit', parentId: null });
+    const plan = f.plan(), work = f.run(); f.allocate(work); assert.equal(work.budgetUsd, 8);
+    Object.assign(work, { status: 'running', invocations: [{ status: 'running', pid: process.pid }] }); f.save(work);
+    process.env.NCCGS_SUPERVISED_RUN = work.id; process.env.NCCGS_SUPERVISED_SESSION = work.sessionId;
+    f.locked(work, () => {
+      assert.equal(plannedDispatchBudget(f.project, 'root', { kind: 'analysis' }).phase, 'work');
+      assert.throws(() => plannedDispatchBudget(f.project, 'root', { kind: 'review' }), /protected final-review/);
+    });
+    work.invocations = []; f.finish(work, 3);
+    const review = f.run(); f.allocate(review, 'final-review'); assert.equal(review.budgetUsd, 9); assert.equal(review.deadline, plan.deadline);
+    Object.assign(review, { status: 'running', invocations: [{ status: 'running', pid: process.pid }] }); f.save(review);
+    process.env.NCCGS_SUPERVISED_RUN = review.id; process.env.NCCGS_SUPERVISED_SESSION = review.sessionId;
+    f.locked(review, () => {
+      assert.equal(plannedDispatchBudget(f.project, 'root', { kind: 'review' }).phase, 'final-review');
+      for (const kind of ['analysis', 'implementation']) assert.throws(() => plannedDispatchBudget(f.project, 'root', { kind }), /cannot dispatch/);
+    });
+    review.invocations = []; f.finish(review, 2);
+    delete process.env.NCCGS_SUPERVISED_RUN; delete process.env.NCCGS_SUPERVISED_SESSION;
+    assert.equal(reviewBudgetStatus(f.project, 'root').settledCostUsd, 5);
+  } finally { names.forEach((n,i) => { if(saved[i]===undefined) delete process.env[n]; else process.env[n]=saved[i]; }); f.dispose(); }
+});
+
+test('plan design review remains unable to consume the final delivery reserve', () => {
+  const f = fixture(); try { f.plan(); const design = f.run(); assert.throws(() => f.allocate(design, 'final-review'), /design review/); }
+  finally { f.dispose(); }
+});
+
+test('the work time window stops before the protected review window without extending the original deadline', () => {
+  const f = fixture(), realNow = Date.now; try {
+    const plan = f.plan(); Date.now = () => plan.workDeadline + 1;
+    const work = f.run('delivery'); assert.throws(() => f.allocate(work), /exhausted/);
+    Object.assign(work, { status: 'blocked', costCoverage: 'complete', cumulativeCostUsd: 0 }); f.save(work);
+    const review = f.run('delivery'); f.allocate(review, 'final-review'); assert.equal(review.deadline, plan.deadline);
+    Date.now = () => plan.deadline + 1; assert.throws(() => f.allocate(review, 'final-review'), /exhausted/);
+  } finally { Date.now = realNow; f.dispose(); }
+});
+test('spent money cannot be retroactively reserved and initialized budget history cannot be erased', () => {
+  const f = fixture(); try {
+    const old = f.run(); f.finish(old, 11.589259);
+    assert.throws(() => f.plan(), /retroactively/);
+  } finally { f.dispose(); }
+  const g = fixture(); try {
+    g.plan(); const file = path.join(g.project, '.nccgs/budgets/root.json'); fs.renameSync(file, file + '.archived');
+    assert.throws(() => g.plan(), /history is missing/);
+  } finally { g.dispose(); }
+});