@bongos/core 1.24.3 → 1.24.5

package/tests/reward_cost_scale.mjs

@@ -0,0 +1,200 @@
+// tests/reward_cost_scale.mjs — task 1004968 (goal 1000092, ADR 0387).
+//
+// The reward sizing factor was called `usdPeg`, which read as an exchange rate
+// between a credit and a dollar. It is now `costScale`. This file pins three
+// things the rename must not change:
+//
+//   1. AWARDS ARE BYTE-IDENTICAL. The amounts below are LITERALS computed with
+//      the pre-rename formula (round(cost × 1.20 × peg)), not re-derived from the
+//      code under test, so a change to the formula reds here. They are checked
+//      for the neutral pack and for a host pack that sets ONLY the old key.
+//   2. THE OLD KEY STILL WORKS. A pack carrying only `usdPeg` resolves to the
+//      same factor, through the REAL branding read (a child process per pack,
+//      because branding() is memoised), with a one-line deprecation note printed
+//      once. When both keys are set, `costScale` wins.
+//   3. NO LEDGER ROW IS REWRITTEN. No migration names either key: the rename
+//      lives in config and code only, so nothing converts, rescales or rewrites
+//      an existing credit_log row.
+
+import { createRequire } from 'node:module';
+import { strict as assert } from 'node:assert';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const {
+  rewardPolicy, resolveCostScale, rewardPolicyDeprecation, USD_PEG_DEPRECATION,
+} = require('../modules/economy/reward-policy.js');
+const { computeSessionTokenReward } = require('../modules/economy/credits.js');
+
+const { test, summary } = makeRunner();
+
+// [true cost USD, awarded credits at scale 1, awarded credits at scale 2.5].
+// Computed with the PRE-rename formula; literals on purpose.
+const PINNED = [
+  [0, 0, 0],
+  [0.40, 0, 1],
+  [0.42, 1, 1],
+  [1.65, 2, 5],
+  [7.3333, 9, 22],
+  [15, 18, 45],
+  [100, 120, 300],
+];
+
+function award(policy, cost) {
+  return computeSessionTokenReward(cost, policy.marginPct, policy.costScale);
+}
+
+await test('neutral pack: awards and descriptions are byte-identical to before the rename', () => {
+  const neutral = JSON.parse(fs.readFileSync(path.join(ROOT, 'config/branding.neutral.json'), 'utf8'));
+  // The neutral pack carries NEITHER key: a host pack deep-merges over it, so a
+  // neutral `costScale: 1` would win over a host's `usdPeg` and silently reset
+  // that host's awards to scale 1. The default 1 lives in code instead.
+  assert.equal(neutral.reward.costScale, undefined, 'neutral must not shadow a host usdPeg');
+  assert.equal(neutral.reward.usdPeg, undefined, 'and no longer carries the old key');
+  const p = rewardPolicy(neutral.reward);
+  for (const [cost, at1] of PINNED) {
+    const r = award(p, cost);
+    assert.equal(r.drachmae, at1, `$${cost} at the neutral pack`);
+  }
+  // At scale 1 the description carries no factor at all, so it is unchanged too.
+  assert.equal(award(p, 15).description, '$15.00 true cost × 1.20 = 18 drachmae (token reward)');
+});
+
+await test('a pack that sets ONLY usdPeg awards exactly what it did before', () => {
+  const p = rewardPolicy({ marginPct: 20, usdPeg: 2.5 });
+  assert.equal(p.costScale, 2.5, 'the old key is still read');
+  for (const [cost, , at25] of PINNED) {
+    assert.equal(award(p, cost).drachmae, at25, `$${cost} at usdPeg 2.5`);
+  }
+  // A pack using the old key and one using the new key are indistinguishable.
+  const q = rewardPolicy({ marginPct: 20, costScale: 2.5 });
+  for (const [cost] of PINNED) assert.deepEqual(award(q, cost), award(p, cost));
+});
+
+await test('the factor is written as a scale, never a peg (ADR 0387)', () => {
+  const d = award(rewardPolicy({ usdPeg: 2 }), 15).description;
+  assert.equal(d, '$15.00 true cost × 1.20 × 2 scale = 36 drachmae (token reward)');
+  assert.doesNotMatch(d, /peg/i);
+});
+
+await test('both keys set: costScale wins', () => {
+  assert.equal(resolveCostScale({ costScale: 3, usdPeg: 2 }), 3);
+  assert.equal(rewardPolicy({ costScale: 3, usdPeg: 2 }).costScale, 3);
+});
+
+await test('an invalid costScale falls back to a working usdPeg, then to 1', () => {
+  for (const bad of [0, -1, 'x', null, undefined, NaN, Infinity]) {
+    assert.equal(resolveCostScale({ costScale: bad, usdPeg: 2 }), 2, `costScale=${String(bad)} → usdPeg`);
+    assert.equal(resolveCostScale({ costScale: bad }), 1, `costScale=${String(bad)} alone → 1`);
+    assert.equal(resolveCostScale({ usdPeg: bad }), 1, `usdPeg=${String(bad)} alone → 1 (as before)`);
+  }
+  assert.equal(resolveCostScale(null), 1);
+});
+
+await test('the deprecation note: only for a pack still spelling usdPeg alone', () => {
+  assert.equal(rewardPolicyDeprecation({ usdPeg: 1 }), USD_PEG_DEPRECATION);
+  assert.equal(rewardPolicyDeprecation({ costScale: 1 }), null);
+  assert.equal(rewardPolicyDeprecation({ costScale: 1, usdPeg: 1 }), null, 'costScale wins, so the old key is unused');
+  assert.equal(rewardPolicyDeprecation({}), null);
+  assert.equal(rewardPolicyDeprecation(null), null);
+  assert.equal(USD_PEG_DEPRECATION.split('\n').length, 1, 'one line');
+  assert.match(USD_PEG_DEPRECATION, /costScale/);
+});
+
+// The REAL branding read: rewardConfig() through the module port, with a host
+// pack that deep-merges over neutral. One child per pack, because branding() is
+// memoised for the life of a process.
+function resolveInChild(reward) {
+  const file = path.join(os.tmpdir(), `bongos-cost-scale-${process.pid}-${Object.keys(reward).join('-')}.json`);
+  fs.writeFileSync(file, JSON.stringify({ reward }));
+  const script = `
+    const credits = require(${JSON.stringify(path.join(ROOT, 'modules/economy/credits.js'))});
+    const a = credits.rewardConfig();
+    const b = credits.rewardConfig();
+    process.stdout.write('\\nRESULT=' + JSON.stringify({ a, b, award: credits.computeSessionTokenReward(1.65, a.marginPct, a.costScale) }) + '\\n');
+  `;
+  try {
+    const out = execFileSync(process.execPath, ['-e', script], {
+      cwd: ROOT,
+      env: { ...process.env, BONGOS_BRANDING_FILE: file },
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    // The deprecation note goes through the module logger, which may share
+    // stdout, so the result line is marked rather than being the whole output.
+    const line = out.split('\n').find((l) => l.startsWith('RESULT='));
+    return { result: JSON.parse(line.slice('RESULT='.length)) };
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+}
+
+function stderrOfChild(reward) {
+  const file = path.join(os.tmpdir(), `bongos-cost-scale-err-${process.pid}-${Object.keys(reward).join('-')}.json`);
+  fs.writeFileSync(file, JSON.stringify({ reward }));
+  const errFile = `${file}.err`;
+  const script = `
+    const credits = require(${JSON.stringify(path.join(ROOT, 'modules/economy/credits.js'))});
+    credits.rewardConfig(); credits.rewardConfig(); credits.rewardConfig();
+  `;
+  const fd = fs.openSync(errFile, 'w');
+  try {
+    execFileSync(process.execPath, ['-e', script], {
+      cwd: ROOT,
+      env: { ...process.env, BONGOS_BRANDING_FILE: file },
+      // Both streams: the note goes through the module logger, and the test must
+      // not depend on which stream the logger writes to.
+      stdio: ['ignore', fd, fd],
+    });
+    return fs.readFileSync(errFile, 'utf8');
+  } finally {
+    fs.closeSync(fd);
+    fs.rmSync(file, { force: true });
+    fs.rmSync(errFile, { force: true });
+  }
+}
+
+await test('real branding read: a usdPeg-only host pack resolves and awards as before', () => {
+  const { result } = resolveInChild({ usdPeg: 2.5 });
+  assert.equal(result.a.costScale, 2.5);
+  assert.equal(result.award.drachmae, 5, 'the pinned $1.65 award at 2.5');
+});
+
+await test('real branding read: costScale wins over usdPeg in a host pack', () => {
+  const { result } = resolveInChild({ costScale: 3, usdPeg: 2 });
+  assert.equal(result.a.costScale, 3);
+});
+
+await test('real branding read: the note prints ONCE for a usdPeg pack, never for a costScale pack', () => {
+  const legacy = stderrOfChild({ usdPeg: 2 });
+  const hits = legacy.split(USD_PEG_DEPRECATION).length - 1;
+  assert.equal(hits, 1, `printed exactly once across three resolutions (stderr: ${legacy})`);
+  const moved = stderrOfChild({ costScale: 2 });
+  assert.ok(!moved.includes(USD_PEG_DEPRECATION), 'a moved pack is not nagged');
+});
+
+await test('no migration converts, rescales or rewrites a credit_log row for this rename', () => {
+  const dirs = [path.join(ROOT, 'migrations')];
+  const modulesDir = path.join(ROOT, 'modules');
+  for (const m of fs.readdirSync(modulesDir)) {
+    const d = path.join(modulesDir, m, 'migrations');
+    if (fs.existsSync(d)) dirs.push(d);
+  }
+  let scanned = 0;
+  for (const d of dirs) {
+    for (const f of fs.readdirSync(d).filter((n) => n.endsWith('.sql'))) {
+      scanned += 1;
+      const sql = fs.readFileSync(path.join(d, f), 'utf8');
+      assert.doesNotMatch(sql, /costScale|cost_scale|usdPeg|usd_peg/i, `${f} must not touch the sizing factor`);
+    }
+  }
+  assert.ok(scanned > 100, `the scan saw the migration set (${scanned} files), not an empty directory`);
+});
+
+summary();

package/tests/run_node_reroute.mjs

@@ -0,0 +1,136 @@
+// tests/run_node_reroute.mjs — the hook resolver runs the SESSION's copy of a hook
+// (.claude/hooks/run-node.sh, task 1005015). Claude Code sets $CLAUDE_PROJECT_DIR to the
+// main checkout even in a worktree session, so every hook ran from there; on a stale main
+// checkout that hid the human-task markers (task 1004922) entirely. Each case builds fake
+// checkouts, SPAWNS the real resolver with the real settings.json argument shape, and
+// lets a probe hook report which file ran and what CLAUDE_PROJECT_DIR it saw.
+//
+// The guard hooks run through the resolver too, so the decoy cases matter as much as
+// the happy path: only a linked git worktree OF THIS PROJECT may have its copy run.
+//
+// .claude/hooks/ is package-excluded, so a clean core checkout skips this file
+// (tests/host_topology_skips.mjs carries the allowlist entry).
+//
+// Run:  node tests/run_node_reroute.mjs
+
+import { strict as assert } from 'node:assert';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { skipUnlessPresent } from './helpers.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const RESOLVER = path.join(ROOT, '.claude', 'hooks', 'run-node.sh');
+
+let passed = 0;
+let failed = 0;
+function t(name, fn) {
+  try { fn(); passed++; console.log(`  PASS  ${name}`); } catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+skipUnlessPresent(['.claude/hooks/run-node.sh']);
+
+const PROBE = "process.stdout.write(JSON.stringify({ file: __filename, pd: process.env.CLAUDE_PROJECT_DIR }))\n";
+
+// A fake Bongos checkout. `linkTo` makes it a linked worktree of that main checkout the
+// way git does: a .git FILE naming <main>/.git/worktrees/<name>, whose gitdir file points
+// back (git writes forward slashes on every platform). `backTo` forges a wrong back-pointer.
+const fwd = (p) => p.split(path.sep).join('/');
+function checkout(dir, { linkTo = null, backTo = null, core = true, probe = true } = {}) {
+  fs.mkdirSync(path.join(dir, '.claude', 'hooks'), { recursive: true });
+  fs.copyFileSync(RESOLVER, path.join(dir, '.claude', 'hooks', 'run-node.sh'));
+  if (probe) fs.writeFileSync(path.join(dir, '.claude', 'hooks', 'probe.js'), PROBE);
+  if (linkTo) {
+    const admin = path.join(linkTo, '.git', 'worktrees', path.basename(dir));
+    fs.mkdirSync(admin, { recursive: true });
+    fs.writeFileSync(path.join(admin, 'gitdir'), `${fwd(path.join(backTo || dir, '.git'))}\n`);
+    fs.writeFileSync(path.join(dir, '.git'), `gitdir: ${fwd(admin)}\n`);
+  } else {
+    fs.mkdirSync(path.join(dir, '.git'), { recursive: true });
+  }
+  if (core) fs.mkdirSync(path.join(dir, 'src', 'bongos'), { recursive: true });
+  return dir;
+}
+
+// The argument shape settings.json uses: "$CLAUDE_PROJECT_DIR/.claude/hooks/<hook>.js".
+function run({ main, cwd, env = {} }) {
+  const r = spawnSync('sh', [path.join(main, '.claude', 'hooks', 'run-node.sh'), `${main}/.claude/hooks/probe.js`], {
+    cwd,
+    env: { ...process.env, CLAUDE_PROJECT_DIR: main, OTB_NODE_BIN: process.execPath, OTB_HOOKS_FROM_PROJECT_DIR: '', ...env },
+    encoding: 'utf8',
+  });
+  if (r.error) throw r.error;
+  assert.equal(r.status, 0, `resolver exited ${r.status}: ${r.stderr}`);
+  return JSON.parse(r.stdout);
+}
+
+// Windows paths are case-insensitive, and the resolver hands node a lower-case drive.
+const canon = (p) => (process.platform === 'win32' ? fs.realpathSync.native(p).toLowerCase() : fs.realpathSync(p));
+const same = (a, b) => canon(a) === canon(b);
+
+if (spawnSync('sh', ['-c', 'exit 0']).status !== 0) {
+  console.log('SKIP run_node_reroute: no `sh` on PATH');
+  process.exit(0);
+}
+
+// realpath: on Windows os.tmpdir() can be an 8.3 short name (GMK1_P~1), which git never
+// writes and the shell's $PWD never shows, so the fixture's paths would not compare.
+const tmp = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'run-node-reroute-')));
+const main = checkout(path.join(tmp, 'main'));
+const MAIN_PROBE = path.join(main, '.claude', 'hooks', 'probe.js');
+const wt = checkout(path.join(main, '.claude', 'worktrees', 'wt'), { linkTo: main });
+fs.mkdirSync(path.join(wt, 'deep', 'er'), { recursive: true });
+const ranMain = (out) => assert.ok(same(out.file, MAIN_PROBE), `ran ${out.file}`);
+
+t('a hook fired from inside a worktree runs the worktree\'s copy, with CLAUDE_PROJECT_DIR pointed at it', () => {
+  const out = run({ main, cwd: path.join(wt, 'deep', 'er') });
+  assert.ok(same(out.file, path.join(wt, '.claude', 'hooks', 'probe.js')), `ran ${out.file}`);
+  assert.ok(same(out.pd, wt), `CLAUDE_PROJECT_DIR was ${out.pd}`);
+});
+
+t('a linked worktree outside the main folder reroutes too', () => {
+  const linked = checkout(path.join(tmp, 'linked'), { linkTo: main });
+  const out = run({ main, cwd: linked });
+  assert.ok(same(out.file, path.join(linked, '.claude', 'hooks', 'probe.js')), `ran ${out.file}`);
+});
+
+t('a hook fired from the main checkout itself runs unchanged', () => {
+  const out = run({ main, cwd: main });
+  ranMain(out);
+  assert.equal(out.pd, main);
+});
+
+t('OTB_HOOKS_FROM_PROJECT_DIR=1 turns the reroute off', () => {
+  ranMain(run({ main, cwd: wt, env: { OTB_HOOKS_FROM_PROJECT_DIR: '1' } }));
+});
+
+t('a worktree that cannot resolve the core (no src/bongos, no node_modules) keeps the main copy', () => {
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'bare'), { linkTo: main, core: false }) }));
+});
+
+t('a worktree whose branch lacks the hook keeps the main copy', () => {
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'old'), { linkTo: main, probe: false }) }));
+});
+
+t('a folder outside any checkout keeps the main copy', () => {
+  ranMain(run({ main, cwd: fs.mkdtempSync(path.join(os.tmpdir(), 'run-node-loose-')) }));
+});
+
+t('a look-alike with a .git dir and its own hooks (not a worktree) keeps the main copy', () => {
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'decoy')) }));
+});
+
+t('a decoy whose .git file names a gitdir outside the project keeps the main copy', () => {
+  const other = checkout(path.join(tmp, 'other-main'));
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'decoy2'), { linkTo: other }) }));
+});
+
+t('a decoy pointing into the project whose back-pointer names another folder keeps the main copy', () => {
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'decoy3'), { linkTo: main, backTo: wt }) }));
+});
+
+fs.rmSync(tmp, { recursive: true, force: true });
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exitCode = failed ? 1 : 0;