nccgs 2.1.0 → 3.0.0-rc.1

package/tests/review-budget.test.mjs

@@ -1,177 +0,0 @@
-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(); }
-});