@bongos/core 1.24.2 → 1.24.4

package/tests/market_watch_ask_db.mjs

@@ -0,0 +1,122 @@
+// tests/market_watch_ask_db.mjs — the weekly ask's SQL store against a REAL Postgres (task
+// 1004940, goal 1000137).
+//
+// What only a real engine can say: the week's ask is issued once per project per week (the
+// UNIQUE constraint, not the caller's care); an answer cannot land on another project's ask
+// (the guard is in the INSERT ... SELECT); similar answers from three members file ONE
+// proposal whose agree count is three; a second tap is a no-op; and the rows satisfy the
+// proposals table's own CHECKs (a weekly_ask proposal carries its answer, a rule_change its
+// rules version).
+//
+// The module is default:false, so CI's migrate.sh does not apply its migrations; this file
+// applies market_watch_001, 002 and 003 itself. Its rows live under a project origin no real
+// instance has and are deleted before and after. Self-skips without a reachable Postgres;
+// in the INTEGRATION set (scripts/bongos/run-unit-tests.js). DB-free sibling:
+// tests/market_watch_ask.mjs.
+//
+// Run:  DATABASE_URL=... node tests/market_watch_ask_db.mjs
+
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { strict as assert } from 'node:assert';
+import { insertTestBuilders } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+const ask = require('../modules/market-watch/ask.js');
+
+const M1 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_001_tables.sql', import.meta.url), 'utf8');
+const M2 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_002_run.sql', import.meta.url), 'utf8');
+const M3 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_003_ask_pool.sql', import.meta.url), 'utf8');
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`market_watch_ask_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+const P = 'https://t1004940-ask.example';
+const OTHER = 'https://t1004940-other.example';
+const ADA = 91004940, BEN = 91004941, CY = 91004942;
+const NOW = new Date('2026-10-29T12:00:00Z');
+const q = (sql, params) => pool.query(sql, params);
+
+async function cleanup() {
+  for (const project of [P, OTHER]) {
+    await q(`DELETE FROM market_watch_proposals WHERE project = $1`, [project]).catch(() => {});
+    await q(`DELETE FROM market_watch_ask_answers WHERE ask_id IN (SELECT id FROM market_watch_weekly_asks WHERE project = $1)`, [project]).catch(() => {});
+    await q(`DELETE FROM market_watch_weekly_asks WHERE project = $1`, [project]).catch(() => {});
+    await q(`DELETE FROM market_watch_items WHERE project = $1`, [project]).catch(() => {});
+    await q(`DELETE FROM market_watch_rule_versions WHERE project = $1`, [project]).catch(() => {});
+  }
+  await q(`DELETE FROM builders WHERE id = ANY($1::bigint[])`, [[ADA, BEN, CY]]).catch(() => {});
+}
+
+let failed = 0;
+async function check(name, fn) {
+  try { await fn(); console.log(`ok - ${name}`); } catch (e) { failed += 1; console.log(`not ok - ${name}\n  ${e && e.stack}`); }
+}
+
+try {
+  await q(M1);
+  await q(M2);
+  await q(M3);
+  await q(M3);
+  await cleanup();
+  await insertTestBuilders(pool, [{ id: ADA, login: 't1004940-ada' }, { id: BEN, login: 't1004940-ben' }, { id: CY, login: 't1004940-cy' }]);
+  await q(`INSERT INTO market_watch_rule_versions (project, version, status, reason) VALUES ($1, 1, 'active', 'test rules')`, [P]);
+  for (const [kind, name, category] of [
+    ['competitor', 'Lovable', 'AI app builder'], ['competitor', 'Bolt.new', 'AI app builder'],
+    ['competitor', 'Factory', 'AI software-engineering agent'], ['partner', 'Colony', 'DAO tooling'],
+  ]) await q(`INSERT INTO market_watch_items (project, kind, name, url, category) VALUES ($1, $2, $3, '', $4)`, [P, kind, name, category]);
+  const store = ask.createAskStore(pool);
+
+  await check('the week is issued once per project, with chips from the project\'s own items', async () => {
+    assert.equal((await ask.issueWeeklyAsk(store, { project: P, now: NOW })).created, 2);
+    assert.equal((await ask.issueWeeklyAsk(store, { project: P, now: NOW })).created, 0);
+    // Even a direct second insert is refused by the constraint, not by the caller.
+    assert.equal(await store.insertAsk(P, { weekOf: '2026-10-26', questionKey: 'rival', prompt: 'x', options: [], closesAt: NOW }), false);
+    const asks = await store.asksForWeek(P, '2026-10-26');
+    assert.deepEqual(asks.map((a) => a.question_key), ['rival', 'watch']);
+    assert.deepEqual(asks[0].options.map((o) => o.label), ['AI app builder', 'AI software-engineering agent']);
+    assert.deepEqual(asks[1].options.map((o) => o.label), ['DAO tooling']);
+  });
+
+  await check('three members, one pool: one proposal, three agree, and the card is gone for each', async () => {
+    const r1 = await ask.answer(store, { project: P, builderId: ADA, now: NOW, body: { picks: [{ question: 'rival', choice: 'AI app builder' }], names: [{ question: 'rival', text: 'Kilo Code' }] } });
+    assert.equal(r1.status, 200, JSON.stringify(r1.body));
+    assert.deepEqual([r1.body.answers, r1.body.proposals], [2, 2]);
+    const r2 = await ask.answer(store, { project: P, builderId: BEN, now: NOW, body: { names: [{ question: 'rival', text: 'kilo-code' }] } });
+    assert.deepEqual([r2.body.proposals, r2.body.pooled], [0, 1]);
+    const r3 = await ask.answer(store, { project: P, builderId: CY, now: NOW, body: { names: [{ question: 'rival', text: 'The Kilo Code' }] } });
+    assert.deepEqual([r3.body.proposals, r3.body.pooled], [0, 1]);
+    const again = await ask.answer(store, { project: P, builderId: ADA, now: NOW, body: { picks: [{ question: 'rival', choice: 'AI app builder' }] } });
+    assert.equal(again.body.answers, 0, 'a second tap is a no-op');
+    const team = await store.teamProposals(P, '2026-10-26');
+    assert.equal(team.length, 2);
+    assert.deepEqual([team[0].payload.name, team[0].agree, team[0].who], ['Kilo Code', 3, 't1004940-ada']);
+    const { rows } = await q(`SELECT kind, origin, answer_id, rule_version_id FROM market_watch_proposals WHERE project = $1 ORDER BY id`, [P]);
+    assert.equal(rows[0].kind, 'rule_change');
+    assert.ok(rows[0].rule_version_id && rows.every((r) => r.origin === 'weekly_ask' && r.answer_id));
+    for (const b of [ADA, BEN, CY]) assert.equal(await ask.cardFor(store, { project: P, builderId: b, now: NOW }), null);
+  });
+
+  await check('an answer cannot land on another project\'s ask', async () => {
+    await ask.issueWeeklyAsk(store, { project: OTHER, now: NOW });
+    const [other] = await store.asksForWeek(OTHER, '2026-10-26');
+    const id = await store.tx((t) => t.insertAnswer({ project: P, askId: other.id, builderId: ADA, choice: 'x', freeText: null }));
+    assert.equal(id, null);
+  });
+} finally {
+  await cleanup();
+  await pool.end();
+}
+
+if (failed) {
+  console.log(`market_watch_ask_db.mjs: ${failed} failed`);
+  process.exit(1);
+}
+console.log('market_watch_ask_db.mjs: all passed');

package/tests/market_watch_data_db.mjs

@@ -28,6 +28,7 @@ const db = require('../modules/market-watch/db.js');
 
 const MIGRATION = readFileSync(new URL('../modules/market-watch/migrations/market_watch_001_tables.sql', import.meta.url), 'utf8');
 const MIGRATION_002 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_002_run.sql', import.meta.url), 'utf8');
+const MIGRATION_003 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_003_ask_pool.sql', import.meta.url), 'utf8');
 const run = require('../modules/market-watch/run.js');
 const store = require('../modules/market-watch/store.js');
 
@@ -80,6 +81,9 @@ try {
     // 'run' proposal origin. A new migration here joins this file (CI never applies it).
     await q(MIGRATION_002);
     await q(MIGRATION_002);
+    // market_watch_003 (task 1004940): the weekly ask's pool-lookup index.
+    await q(MIGRATION_003);
+    await q(MIGRATION_003);
     const { rows } = await q(`SELECT count(*)::int AS n FROM information_schema.tables WHERE table_name LIKE 'market\\_watch\\_%'`);
     assert.ok(rows[0].n >= 10, `tables: ${rows[0].n}`);
   });

package/tests/market_watch_module.mjs

@@ -2,7 +2,7 @@
 // the loader, and an instance boots with it present and DISABLED (task 1004935, goal
 // 1000137). DB-free, so it runs in the unit lane.
 //
-// The module mounts no routes yet; task 1004936 gave it its tables and a one-shot hub seed
+// Task 1004940 mounted its first routes (the weekly ask); task 1004936 gave it its tables and a one-shot hub seed
 // poller (tests/market_watch_data.mjs covers those). What this file
 // pins is everything the later Market Watch tasks will stand on:
 //   1. the manifest validates, ships default:false, and declares spend.requiresPayer;
@@ -26,7 +26,7 @@ const mods = require('../src/modules.js');
 const bundles = require('../modules/provisioning/starter-bundles.js');
 const scopeMap = require('../src/bongos/module-scope-map.js');
 
-test('the manifest validates, ships disabled, declares a payer, and contributes only its data', () => {
+test('the manifest validates, ships disabled, declares a payer, and contributes what the goal has built', () => {
   const v = validateManifest(manifest);
   assert.equal(v.valid, true, `manifest errors: ${v.errors.join('; ')}`);
   assert.equal(manifest.key, KEY);
@@ -34,9 +34,13 @@ test('the manifest validates, ships disabled, declares a payer, and contributes
   assert.equal(manifest.spend && manifest.spend.requiresPayer, true,
     'every run spends the project AI budget, so the payer guard is declared before the first route');
   // Task 1004936 added its tables and the one-shot hub seed; task 1004937 the weekly-run
-  // poller. There are still no routes.
-  assert.deepEqual(manifest.contributes, { migrations: true, pollers: ['hub-seed', 'weekly-run'] },
-    'its tables, the hub seed and the weekly run, nothing to mount');
+  // poller; task 1004940 the weekly ask (its poller, its routes and its hall slice). Each
+  // screen task adds its own entries, so this pins what must be there, not the whole list.
+  const c = manifest.contributes;
+  assert.equal(c.migrations, true);
+  for (const p of ['hub-seed', 'weekly-run', 'weekly-ask']) assert.ok(c.pollers.includes(p), `poller ${p}`);
+  assert.ok(c.routes.includes('ask'), 'the weekly ask routes');
+  assert.ok(c.uiSections.includes('weekly-ask'), 'the weekly ask hall slice (hallWidgetScripts needs a uiSection)');
 });
 
 test('the loader discovers it from the live tree — loaded, not an error, not skipped', () => {

package/tests/project_settings_page.mjs

@@ -57,7 +57,7 @@ const fakeRes = () => ({
 // The router is built against the REAL module-api and the REAL goal-category; only
 // the two calls that would reach Postgres are swapped. Stubbing the row builders
 // instead would prove nothing about the shape the page actually receives.
-const WORKING_REWARD = { rewardConfig: () => ({ marginPct: 20, usdPeg: 1, mode: 'cost-plus-only', perTaskCredit: false, ideatorCredit: true }) };
+const WORKING_REWARD = { rewardConfig: () => ({ marginPct: 20, costScale: 1, mode: 'cost-plus-only', perTaskCredit: false, ideatorCredit: true }) };
 function buildRouterWithStubs({ timer, categories, reward = WORKING_REWARD }) {
   const saved = {
     resolveRotDays: api.resolveRotDays,

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();