@bongos/core 1.24.7 → 1.24.9

package/tests/market_watch_rules_db.mjs

@@ -0,0 +1,133 @@
+// tests/market_watch_rules_db.mjs — the rules page's round trip against a REAL Postgres
+// (task 1004941, goal 1000137).
+//
+// What only a real engine can say: a member's proposal is filed under the table's CHECKs
+// (a rule change must name its version), approving it supersedes the version in use and
+// writes the next one in one transaction without tripping the one-active index, the new
+// row records who proposed it, who approved it, when and why, and the weekly run's own
+// rules loader (store.createStore(pool).activeRules, what run.js calls) then reads it.
+// Also: an approved add-item proposal creates the tracked item, and the page's read
+// (rules-view.readView, with its last-run-cost and builder-name SQL) runs.
+//
+// The module is default:false, so CI's migrate.sh never applies its SQL: this file
+// applies market_watch_001 and 002 itself. Rows live under a project origin no 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 half: tests/market_watch_rules.mjs.
+//
+// Run:  DATABASE_URL=... node tests/market_watch_rules_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 seed = require('../modules/market-watch/seed.js');
+const store = require('../modules/market-watch/store.js');
+const proposals = require('../modules/market-watch/proposals.js');
+const view = require('../modules/market-watch/rules-view.js');
+const research = require('../modules/market-watch/research.js');
+const pricing = require('../src/bongos/llm-pricing.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 pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`market_watch_rules_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+const P = 'https://t1004941-rules.example';
+const OWNER = 91049411, ADA = 91049412;
+const q = (sql, params) => pool.query(sql, params);
+const withTx = async (fn) => {
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+    const out = await fn(client);
+    await client.query('COMMIT');
+    return out;
+  } catch (e) {
+    await client.query('ROLLBACK').catch(() => {});
+    throw e;
+  } finally { client.release(); }
+};
+
+async function cleanup() {
+  await q(`DELETE FROM market_watch_proposals WHERE project = $1`, [P]).catch(() => {});
+  await q(`DELETE FROM market_watch_items WHERE project = $1`, [P]).catch(() => {});
+  await q(`DELETE FROM market_watch_rule_versions WHERE project = $1`, [P]).catch(() => {});
+  await q(`DELETE FROM builders WHERE id = ANY($1::bigint[])`, [[OWNER, ADA]]).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(MIGRATION);
+  await q(MIGRATION_002);
+  await cleanup();
+  await insertTestBuilders(pool, [{ id: OWNER, login: 't1004941-owner' }, { id: ADA, login: 't1004941-ada' }]);
+  const r = seed.RULES_V1;
+  await q(`INSERT INTO market_watch_rule_versions (project, version, status, search_queries, sources, rubric, instructions, summary, reason, approved_at)
+           VALUES ($1, 1, 'active', $2::jsonb, $3::jsonb, $4::jsonb, $5, $6, $7, now())`,
+  [P, JSON.stringify(r.searchQueries), JSON.stringify(r.sources), JSON.stringify(seed.RUBRIC), r.instructions, r.summary, r.reason]);
+
+  await check('a proposal round-trips to a new version, and the weekly run\'s rules loader reads it', async () => {
+    const filed = await proposals.createProposal(pool, {
+      project: P, step: 'searches', change: { op: 'add', text: 'open-source bounty boards' }, reason: 'finds Algora and Opire', proposedBy: ADA,
+    });
+    assert.equal(filed.ok, true, JSON.stringify(filed));
+    const out = await proposals.decideProposal({ project: P, id: filed.proposal.id, decision: 'approve', decidedBy: OWNER, withTx });
+    assert.equal(out.ok, true, JSON.stringify(out));
+    const { rows } = await q(`SELECT version, status, author_id, approved_by, approved_at, reason, search_queries
+                                FROM market_watch_rule_versions WHERE project = $1 ORDER BY version`, [P]);
+    assert.deepEqual(rows.map((v) => [v.version, v.status]), [[1, 'superseded'], [2, 'active']]);
+    assert.equal(String(rows[1].author_id), String(ADA));
+    assert.equal(String(rows[1].approved_by), String(OWNER));
+    assert.ok(rows[1].approved_at instanceof Date);
+    assert.equal(rows[1].reason, 'finds Algora and Opire');
+    const loaded = await store.createStore(pool).activeRules(P);
+    assert.equal(loaded.version, 2);
+    assert.ok(loaded.search_queries.includes('open-source bounty boards'));
+    const { rows: [p] } = await q(`SELECT status, decided_by, rule_version_id FROM market_watch_proposals WHERE id = $1`, [filed.proposal.id]);
+    assert.equal(p.status, 'applied');
+    assert.equal(String(p.rule_version_id), String(out.version.id));
+  });
+
+  await check('an approved add-item proposal creates the tracked item', async () => {
+    const filed = await proposals.createProposal(pool, {
+      project: P, step: 'names', change: { op: 'add', name: 'Algora', url: 'https://algora.io', kind: 'competitor', why: 'bounties' }, reason: 'they pay per task', proposedBy: ADA,
+    });
+    const out = await proposals.decideProposal({ project: P, id: filed.proposal.id, decision: 'approve', decidedBy: OWNER, withTx });
+    assert.equal(out.status, 'applied');
+    const { rows: [it] } = await q(`SELECT kind, url, added_via, added_by, status FROM market_watch_items WHERE project = $1 AND name = 'Algora'`, [P]);
+    assert.deepEqual([it.kind, it.url, it.added_via, String(it.added_by), it.status], ['competitor', 'https://algora.io', 'proposal', String(ADA), 'active']);
+  });
+
+  await check('the page read runs on the real schema', async () => {
+    await proposals.createProposal(pool, { project: P, step: 'brief', change: { op: 'set', text: 'Write five lines.' }, reason: 'shorter', proposedBy: ADA });
+    const page = await view.readView(pool, { project: P, decide: { mode: 'owner' }, pricing, model: research.MODEL });
+    assert.deepEqual(page.history.map((h) => h.version), [1, 2]);
+    assert.equal(page.history[1].by, 't1004941-ada');
+    assert.equal(page.next.version, 3);
+    assert.equal(page.cost.basis, 'estimate', 'no run has cost anything here');
+    assert.equal(page.steps.find((s) => s.key === 'names').value, 1);
+  });
+} finally {
+  await cleanup();
+  await pool.end();
+}
+
+if (failed) {
+  console.log(`market_watch_rules_db.mjs: ${failed} failed`);
+  process.exit(1);
+}
+console.log('market_watch_rules_db.mjs: all passed');

package/tests/module_store_cli.mjs

@@ -133,8 +133,8 @@ test('the same query through both: a sort and a maximum price give the same modu
   for (const [args, query] of [
     [['--sort', 'tests'], { sort: 'tests' }],
     [['--max-cents', '500'], { max_cents: '500' }],
-    [['--max-credits', '0'], { max_credits: '0' }],
-    [['--sort', 'docs', '--max-cents', '1000', '--max-credits', '100'], { sort: 'docs', max_cents: '1000', max_credits: '100' }],
+    [['--max-cents', '0'], { max_cents: '0' }],
+    [['--sort', 'docs', '--max-cents', '1000'], { sort: 'docs', max_cents: '1000' }],
   ]) {
     const api = (await apiGet(query)).body;
     const cli = await cliJson(args);
@@ -144,6 +144,15 @@ test('the same query through both: a sort and a maximum price give the same modu
   }
 });
 
+test('there is no maximum in credits, in the CLI or the API (task 1004989)', async () => {
+  seed();
+  const errs = [];
+  const never = async () => { throw new Error('must not be called'); };
+  assert.equal(await mod.cmdStore(['--max-credits', '100'], { log: () => {}, errlog: (l) => errs.push(l), request: never }), 2);
+  assert.match(errs.join('\n'), /credits do not price modules/);
+  assert.equal((await apiGet({ max_credits: '100' })).statusCode, 400);
+});
+
 test('the text view keeps the API order: listed ranked, then New, and says the floor and the cap', async () => {
   seed();
   const api = (await apiGet({})).body;
@@ -158,7 +167,9 @@ test('the text view keeps the API order: listed ranked, then New, and says the f
   assert.equal(at('stripe-10'), -1, 'the eleventh is not shown');
   assert.match(text, /stripe-00@1\.0\.0 {2}99\/100 {2}free {2}Money › Stripe payments/);
   assert.match(text, /stripe-01@1\.0\.0 {2}98\/100 {2}\$9\.00/);
-  assert.match(text, /loose@1\.0\.0 {2}88\/100 {2}40 credits \(not yet buyable\)$/m, 'no category, no place; paid is not yet buyable (task 1004894)');
+  assert.match(text, /loose@1\.0\.0 {2}88\/100 {2}price coming \(not yet buyable\)$/m,
+    'an old credit-only price shows as price coming, never as credits (task 1004989); no category, no place');
+  assert.doesNotMatch(text, /\d credits/, 'no credit price anywhere in the text view');
   assert.match(text, /waiting@1\.0\.0 {2}60\/100 {2}free {2}Money$/m, 'a proposed sub-category shows its parent only');
   assert.match(text, /New — not ranked[\s\S]*fresh@1\.0\.0/);
 });

package/tests/module_store_listing.mjs

@@ -347,11 +347,27 @@ test('the criterion: two modules with the same overall score read differently',
 // the ranking: quality first, price breaks ties, optional max price (task 1003808)
 // ---------------------------------------------------------------------------
 
-test('priceOf: no price row is free; 0 in either currency is free; null is not offered', () => {
-  assert.deepEqual(priceOf(null), { cents: null, credits: null, free: true });
-  assert.deepEqual(priceOf({ price_cents: 0, price_credits: null }), { cents: 0, credits: null, free: true });
-  assert.deepEqual(priceOf({ price_cents: 500, price_credits: 0 }), { cents: 500, credits: 0, free: true });
-  assert.deepEqual(priceOf({ price_cents: 500, price_credits: null }), { cents: 500, credits: null, free: false });
+test('priceOf: no price row is free; a cash price of 0 is free; never a credit amount', () => {
+  assert.deepEqual(priceOf(null), { cents: null, free: true, coming: false });
+  assert.deepEqual(priceOf({ price_cents: 0, price_credits: null }), { cents: 0, free: true, coming: false });
+  assert.deepEqual(priceOf({ price_cents: 500, price_credits: null }), { cents: 500, free: false, coming: false });
+});
+
+// Task 1004989 (ADR 0385 decision 2; owner, 2026-10-29): OLD rows may carry a
+// credit price. They are read, never shown as a credit price, and never buyable
+// with credits.
+test('priceOf on old credit rows: credit-only is "price coming", 0 credits stays free, cash wins', () => {
+  assert.deepEqual(priceOf({ price_cents: null, price_credits: 40 }), { cents: null, free: false, coming: true },
+    'a module priced only in credits is still listed, with its cash price coming');
+  assert.deepEqual(priceOf({ price_cents: null, price_credits: 0 }), { cents: null, free: true, coming: false },
+    'an old 0-credit offer stays free: no credit moves to have it');
+  assert.deepEqual(priceOf({ price_cents: 500, price_credits: 0 }), { cents: 500, free: true, coming: false },
+    'an old row offered at 0 credits stays free, as it was');
+  assert.deepEqual(priceOf({ price_cents: 500, price_credits: 40 }), { cents: 500, free: false, coming: false },
+    'with a cash price the credit amount is ignored');
+  for (const row of [{ price_credits: 40 }, { price_cents: 500, price_credits: 40 }]) {
+    assert.equal('credits' in priceOf(row), false, 'no credit amount leaves priceOf');
+  }
 });
 
 test('rankListed: a higher score always wins, whatever it costs — price never buys a place', () => {
@@ -362,7 +378,7 @@ test('rankListed: a higher score always wins, whatever it costs — price never
   assert.deepEqual(ranked.map((e) => e.key), ['dear', 'cheap']);
 });
 
-test('rankListed: between equal scores, free first, then lowest cash, then lowest credits, then key', () => {
+test('rankListed: between equal scores, free first, then lowest cash, a price still coming last, then key', () => {
   const input = [
     { key: 'z-credits', overall: 80, price: priceOf({ price_credits: 5 }) },
     { key: 'cents-900', overall: 80, price: priceOf({ price_cents: 900 }) },
@@ -374,14 +390,14 @@ test('rankListed: between equal scores, free first, then lowest cash, then lowes
   assert.equal(input[0].key, 'z-credits', 'the input is untouched');
 });
 
-test('withinMaxPrice: free always passes; a priced module must be offered at or under a cap the buyer set', () => {
+test('withinMaxPrice: free always passes; a priced module must cost at or under the cash cap', () => {
   const p = priceOf({ price_cents: 500, price_credits: 7 });
   assert.equal(withinMaxPrice(p, null), true, 'no cap, no filter');
-  assert.equal(withinMaxPrice(p, { cents: 500, credits: null }), true, 'at the cap is in');
-  assert.equal(withinMaxPrice(p, { cents: 499, credits: null }), false);
-  assert.equal(withinMaxPrice(p, { cents: 1, credits: 7 }), true, 'either currency under its cap is enough');
-  assert.equal(withinMaxPrice(priceOf({ price_cents: 500 }), { cents: null, credits: 100 }), false, 'not offered in credits, so a credit cap cannot let it in');
-  assert.equal(withinMaxPrice(priceOf(null), { cents: 0, credits: null }), true);
+  assert.equal(withinMaxPrice(p, { cents: 500 }), true, 'at the cap is in');
+  assert.equal(withinMaxPrice(p, { cents: 499 }), false);
+  assert.equal(withinMaxPrice(p, { cents: 1, credits: 7 }), false, 'a credit cap is ignored: credits never price a module');
+  assert.equal(withinMaxPrice(priceOf({ price_credits: 7 }), { cents: 100000 }), false, 'a price still coming has no cash price to compare');
+  assert.equal(withinMaxPrice(priceOf(null), { cents: 0 }), true);
 });
 
 test('GET /store/modules: ranks by score then price, and ?max_cents= leaves out what costs more', async () => {
@@ -416,7 +432,7 @@ test('GET /store/modules: ranks by score then price, and ?max_cents= leaves out
   assert.equal(all.body.max_price, null);
 
   const capped = await invoke(handle, { query: { max_cents: '1000' } });
-  assert.deepEqual(capped.body.max_price, { cents: 1000, credits: null });
+  assert.deepEqual(capped.body.max_price, { cents: 1000 });
   assert.deepEqual(capped.body.listed.map((m) => m.key), ['tie-free', 'tie-paid']);
   assert.deepEqual(capped.body.new, [], 'the cap applies to New modules too');
 
@@ -427,13 +443,48 @@ test('GET /store/modules: ranks by score then price, and ?max_cents= leaves out
 
 test('GET /store/modules: a maximum price that is not a whole number of 0 or more is refused', async () => {
   const { handle } = handlerFor(buildModulesRouter(), 'get', '/store/modules');
-  for (const query of [{ max_cents: '-1' }, { max_cents: '5.5' }, { max_credits: 'ten' }, { max_cents: ['1', '2'] }]) {
+  for (const query of [{ max_cents: '-1' }, { max_cents: '5.5' }, { max_cents: ['1', '2'] }]) {
     const res = await invoke(handle, { query });
     assert.equal(res.statusCode, 400, JSON.stringify(query));
     assert.match(res.body.message, /maximum price/);
   }
 });
 
+test('GET /store/modules: there is no maximum in credits (task 1004989)', async () => {
+  const { handle } = handlerFor(buildModulesRouter(), 'get', '/store/modules');
+  for (const query of [{ max_credits: '100' }, { max_credits: 'ten' }, { max_cents: '500', max_credits: '1' }]) {
+    const res = await invoke(handle, { query });
+    assert.equal(res.statusCode, 400, JSON.stringify(query));
+    assert.match(res.body.message, /Credits do not price modules/);
+  }
+});
+
+test('GET /store/modules: an old credit-only price is listed as "price coming", never as credits, and not buyable', async () => {
+  state.modules = { legacy: { status: 'listed', title: 'Legacy' }, cash: { status: 'listed', title: 'Cash' } };
+  state.versions = [
+    { id: 41, module_key: 'legacy', version: '1.0.0', published_at: 't' },
+    { id: 42, module_key: 'cash', version: '1.0.0', published_at: 't' },
+  ];
+  state.scores = [
+    { id: 41, version_id: 41, computed_at: 1, ...score({ overall: 80 }) },
+    { id: 42, version_id: 42, computed_at: 1, ...score({ overall: 80 }) },
+  ];
+  state.signals = [];
+  state.prices = [
+    { module_key: 'legacy', price_cents: null, price_credits: 40, set_at: 1 },
+    { module_key: 'cash', price_cents: 900, price_credits: null, set_at: 1 },
+  ];
+  const { handle } = handlerFor(buildModulesRouter(), 'get', '/store/modules');
+  const res = await invoke(handle, { query: {} });
+  const legacy = res.body.listed.find((m) => m.key === 'legacy');
+  assert.ok(legacy, 'a credit-priced module stays visible (owner, 2026-10-29)');
+  assert.deepEqual(legacy.price, { cents: null, free: false, coming: true });
+  assert.equal(legacy.buyable, false, 'credits never buy it');
+  assert.doesNotMatch(JSON.stringify(res.body), /credits/, 'no credit price appears anywhere in the catalog');
+  assert.deepEqual(res.body.listed.map((m) => m.key), ['cash', 'legacy'], 'between equal scores a price still coming sorts after a cash price');
+  state.prices = [];
+});
+
 // ---------------------------------------------------------------------------
 // why a module is or is not listed (task 1003810)
 // ---------------------------------------------------------------------------

package/tests/module_store_price.mjs

@@ -30,8 +30,11 @@ let state = fresh();
 const newestPrice = (key) => state.prices.filter((p) => p.module_key === key).at(-1) || null;
 const query = async (sql, params = []) => {
   if (/^INSERT INTO store_module_prices/.test(sql)) {
-    const [module_key, price_cents, price_credits, set_by] = params;
-    state.prices.push({ module_key, price_cents, price_credits, set_by, set_at: ++state.setAt });
+    // Reads the column list rather than assuming it, so a writer that still sent
+    // price_credits would be recorded as such and fail the cash-only cases below.
+    const cols = sql.match(/\(([^)]*)\)/)[1].split(',').map((c) => c.trim());
+    const row = Object.fromEntries(cols.map((c, i) => [c, params[i]]));
+    state.prices.push({ price_credits: null, ...row, set_at: ++state.setAt });
     return { rows: [] };
   }
   if (/FROM store_module_prices\s+WHERE module_key = \$1/.test(sql)) {
@@ -105,9 +108,9 @@ test('only the author may set the price; a stranger and a delisted module are re
   assert.equal(state.prices.length, 0, 'nothing was written');
 });
 
-test('a price must be whole numbers of 0 or more, and name at least one currency', async () => {
+test('a price must be a whole number of cents, 0 or more', async () => {
   state = fresh();
-  for (const body of [{}, { cents: null, credits: null }, { cents: -1 }, { cents: 1.5 }, { credits: '10' }, { cents: 1e12 }]) {
+  for (const body of [{}, { cents: null }, { cents: -1 }, { cents: 1.5 }, { cents: '10' }, { cents: 1e12 }]) {
     const r = await setPrice(body);
     assert.equal(r.statusCode, 400, JSON.stringify(body));
     assert.ok(['bad_price', 'validation_failed'].includes(r.body.error.code), r.body.error.code);
@@ -115,21 +118,34 @@ test('a price must be whole numbers of 0 or more, and name at least one currency
   assert.equal(state.prices.length, 0);
 });
 
-test('each change appends a row naming who set it, and the newest is what acquire reads', async () => {
+// Task 1004989 (ADR 0385 decision 2): credits never price or buy a module.
+test('a credit price is refused by name, with or without cents, and nothing is written', async () => {
+  state = fresh();
+  for (const body of [{ credits: 40 }, { credits: 0 }, { cents: 500, credits: 40 }, { credits: '10' }]) {
+    const r = await setPrice(body);
+    assert.equal(r.statusCode, 400, JSON.stringify(body));
+    assert.equal(r.body.error.code, 'credit_price_refused', JSON.stringify(body));
+    assert.match(r.body.error.message, /Credits cannot price a module/);
+  }
+  assert.equal(state.prices.length, 0, 'no row, not even the cash half');
+});
+
+test('each change appends a cash-only row naming who set it, and the newest is what acquire reads', async () => {
   state = fresh();
   const first = await setPrice({ cents: 900 });
   assert.equal(first.statusCode, 200);
-  assert.deepEqual(first.body, { ok: true, module_key: 'weather', previous: null, price: { cents: 900, credits: null } });
-  const second = await setPrice({ cents: 500, credits: 40 });
-  assert.deepEqual(second.body.previous, { cents: 900, credits: null });
+  assert.deepEqual(first.body, { ok: true, module_key: 'weather', previous: null, price: { cents: 900 } });
+  const second = await setPrice({ cents: 500 });
+  assert.deepEqual(second.body.previous, { cents: 900, coming: false });
   assert.equal(state.prices.length, 2, 'the history is kept');
   assert.equal(state.prices[1].set_by, 42);
+  assert.ok(state.prices.every((p) => p.price_credits == null), 'no new row carries a credit price');
   const acq = await store.resolveAcquirable('weather', {});
   assert.equal(acq.ok, true);
-  assert.deepEqual([acq.price.price_cents, acq.price.price_credits], [500, 40]);
+  assert.equal(acq.price.price_cents, 500);
   assert.equal(acq.free, false);
-  await setPrice({ credits: 0 });
-  assert.equal((await store.resolveAcquirable('weather', {})).free, true, '0 in either currency is free');
+  await setPrice({ cents: 0 });
+  assert.equal((await store.resolveAcquirable('weather', {})).free, true, 'a cash price of 0 is free');
 });
 
 test('the catalog shows the price, and marks a paid module not yet buyable until buying opens', async () => {
@@ -139,26 +155,79 @@ test('the catalog shows the price, and marks a paid module not yet buyable until
   assert.equal(cat.listed[0].buyable, true, 'a free module can be had today');
   await setPrice({ cents: 900 });
   cat = await listing.listCatalog({});
-  assert.deepEqual(cat.listed[0].price, { cents: 900, credits: null, free: false });
+  assert.deepEqual(cat.listed[0].price, { cents: 900, free: false, coming: false });
   assert.equal(cat.listed[0].buyable, false, 'buying arrives with task 1003788');
 });
 
-test('bongos module price: sends the price, says what it was and now is, and that paid is not yet buyable', async () => {
+test('an OLD credit-only row: listed as price coming, never free, acquire refuses with no credit path, the author is asked', async () => {
+  state = fresh();
+  state.prices.push({ module_key: 'weather', price_cents: null, price_credits: 40, set_by: 42, set_at: ++state.setAt });
+  const cat = await listing.listCatalog({});
+  assert.deepEqual(cat.listed[0].price, { cents: null, free: false, coming: true });
+  assert.equal(cat.listed[0].buyable, false);
+  const acq = await store.resolveAcquirable('weather', {});
+  assert.equal(acq.free, false, 'credits never make it free or buyable');
+  // The author's listing read carries the ask; a stranger's does not.
+  const mine = await listing.readListing('weather', { viewerId: 42 });
+  assert.equal(mine.price_prompt, listing.PRICE_COMING_PROMPT);
+  assert.match(mine.price_prompt, /set a cash price/);
+  const theirs = await listing.readListing('weather', { viewerId: 7 });
+  assert.equal(theirs.price_prompt, null);
+  assert.deepEqual(theirs.price, { cents: null, free: false, coming: true });
+  // Setting a cash price replaces it; the reply says what it was.
+  const set = await setPrice({ cents: 300 });
+  assert.deepEqual(set.body.previous, { cents: null, coming: true });
+  assert.equal((await listing.readListing('weather', { viewerId: 42 })).price_prompt, null, 'the ask goes away');
+  // An old 0-credit offer stays free, as it was.
+  state = fresh();
+  state.prices.push({ module_key: 'weather', price_cents: null, price_credits: 0, set_by: 42, set_at: ++state.setAt });
+  assert.equal((await store.resolveAcquirable('weather', {})).free, true);
+});
+
+// The hall store row: the real storeFacts lifted out of modules.js and run over a
+// real catalog entry, so the page and the read cannot disagree about the flag.
+test('the hall store row marks a price-coming module, and nothing else', async () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/modules.js'), 'utf8');
+  const start = src.indexOf('  function storeFacts(m) {');
+  const end = src.indexOf('\n  }\n', start);
+  assert.ok(start > 0 && end > start, 'storeFacts is in modules.js');
+  const storeFacts = new Function('escapeHtml', 'sortedPartFact', 'partsList',
+    `${src.slice(start, end + 4)}; return storeFacts;`)((s) => String(s), () => '', () => '');
+  state = fresh();
+  state.prices.push({ module_key: 'weather', price_cents: null, price_credits: 40, set_by: 42, set_at: ++state.setAt });
+  const coming = (await listing.listCatalog({})).listed[0];
+  assert.match(storeFacts(coming), /price coming/);
+  assert.doesNotMatch(storeFacts(coming), /40/, 'the credit amount is never drawn');
+  state = fresh();
+  await setPrice({ cents: 900 });
+  assert.doesNotMatch(storeFacts((await listing.listCatalog({})).listed[0]), /price coming/);
+});
+
+test('the acquire refusal never offers credits as a way to pay', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/modules.js'), 'utf8');
+  const at = src.indexOf("'payment_required'");
+  const block = src.slice(at, at + 600);
+  assert.ok(at > 0);
+  assert.doesNotMatch(block, /credit economy/);
+  assert.match(block, /has no cash price yet/);
+});
+
+test('bongos module price: sends the cash price, says what it was and now is, and that paid is not yet buyable', async () => {
   const sent = [];
   const request = async (method, url, opts) => {
     sent.push({ method, url, json: opts && opts.json });
-    return { ok: true, status: 200, data: { ok: true, previous: { cents: 0, credits: null }, price: { cents: 900, credits: 40 } } };
+    return { ok: true, status: 200, data: { ok: true, previous: { cents: null, coming: true }, price: { cents: 900 } } };
   };
   const out = [];
-  assert.equal(await mod.cmdPrice(['weather', '--cents', '900', '--credits', '40'], { log: (l) => out.push(l), errlog: () => {}, request }), 0);
-  assert.deepEqual(sent, [{ method: 'POST', url: '/store/modules/weather/price', json: { cents: 900, credits: 40 } }]);
-  assert.match(out.join('\n'), /"weather" now costs \$9\.00 or 40 credits \(was free\)/);
+  assert.equal(await mod.cmdPrice(['weather', '--cents', '900'], { log: (l) => out.push(l), errlog: () => {}, request }), 0);
+  assert.deepEqual(sent, [{ method: 'POST', url: '/store/modules/weather/price', json: { cents: 900 } }]);
+  assert.match(out.join('\n'), /"weather" now costs \$9\.00 \(was price coming\)/);
   assert.match(out.join('\n'), /not yet buyable/);
 });
 
-test('bongos module price: refuses no key, no amount and a non-number before asking the store', async () => {
+test('bongos module price: refuses no key, no amount, a non-number and any credit price before asking the store', async () => {
   const request = async () => { throw new Error('must not be called'); };
-  for (const args of [[], ['--cents', '5'], ['weather'], ['weather', '--cents', 'five'], ['weather', '--credits', '-3']]) {
+  for (const args of [[], ['--cents', '5'], ['weather'], ['weather', '--cents', 'five'], ['weather', '--credits', '40'], ['weather', '--cents', '5', '--credits', '1']]) {
     const errs = [];
     assert.equal(await mod.cmdPrice(args, { log: () => {}, errlog: (l) => errs.push(l), request }), 2, args.join(' '));
     assert.match(errs.join('\n'), /usage: bongos module price/);
@@ -183,7 +252,7 @@ test('the price history is the audit: who set each price and when, and what it r
   assert.match(src, /FROM store_modules WHERE module_key = \$1 FOR UPDATE/, 'one transaction, the module row locked');
 });
 
-test('bongos module publish --cents/--credits sets the price after the upload, and checks it before packing', async () => {
+test('bongos module publish --cents sets the price after the upload, and checks it (credits refused) before packing', async () => {
   const packed = { tgz: Buffer.from('x'), sidecar: { module_version: '1.0.0', core_version: '^1.0.0', file_count: 1, tree_sha256: 'a'.repeat(64), tarball: { name: 'x.tgz' } } };
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'publish-price-'));
   fs.mkdirSync(path.join(dir, 'weather'));
@@ -195,13 +264,15 @@ test('bongos module publish --cents/--credits sets the price after the upload, a
   const out = [];
   const code = await mod.cmdPublish(['--cents', '900', 'weather'], { log: (l) => out.push(l), errlog: (l) => out.push(l), modulesDir: dir, pack: () => packed, upload, priceRequest });
   assert.equal(code, 0, out.join('\n'));
-  assert.deepEqual(sent, [['POST', '/store/modules/weather/price', { cents: 900, credits: null }]], 'the key is found even after a valued flag');
+  assert.deepEqual(sent, [['POST', '/store/modules/weather/price', { cents: 900 }]], 'the key is found even after a valued flag');
   let packedAtAll = false;
-  const bad = await mod.cmdPublish(['weather', '--cents', 'nine'], { log: () => {}, errlog: () => {}, modulesDir: dir, pack: () => { packedAtAll = true; return packed; }, upload, priceRequest });
-  assert.equal(bad, 2);
-  assert.equal(packedAtAll, false, 'a bad price refuses before anything is packed or sent');
+  for (const flags of [['--cents', 'nine'], ['--credits', '40']]) {
+    const bad = await mod.cmdPublish(['weather', ...flags], { log: () => {}, errlog: () => {}, modulesDir: dir, pack: () => { packedAtAll = true; return packed; }, upload, priceRequest });
+    assert.equal(bad, 2, flags.join(' '));
+  }
+  assert.equal(packedAtAll, false, 'a bad or credit price refuses before anything is packed or sent');
   const failing = async () => ({ ok: false, status: 403, data: { error: { message: 'Only the author' } } });
   const errs = [];
-  assert.equal(await mod.cmdPublish(['weather', '--credits', '40'], { log: () => {}, errlog: (l) => errs.push(l), modulesDir: dir, pack: () => packed, upload, priceRequest: failing }), 1);
-  assert.match(errs.join('\n'), /The version is published, but its price was not set\. Run `bongos module price weather --credits 40`/);
+  assert.equal(await mod.cmdPublish(['weather', '--cents', '40'], { log: () => {}, errlog: (l) => errs.push(l), modulesDir: dir, pack: () => packed, upload, priceRequest: failing }), 1);
+  assert.match(errs.join('\n'), /The version is published, but its price was not set\. Run `bongos module price weather --cents 40`/);
 });

package/tests/module_store_registry_migration.mjs

@@ -43,6 +43,17 @@ test('a price of zero is allowed in both currencies — free modules are first-c
   assert.match(t, /CHECK \(price_cents IS NOT NULL OR price_credits IS NOT NULL\)/);
 });
 
+// Task 1004989 (ADR 0385 decision 2): a NEW price row may not carry credits, and
+// the old rows stay readable — so the CHECK is NOT VALID and must stay that way.
+test('core_287: new price rows are cash only; old credit rows are kept, not re-checked', () => {
+  const sql = readFileSync(path.join(ROOT, 'migrations', 'core_287_module_prices_cash_only.sql'), 'utf8')
+    .replace(/--[^\n]*/g, '');
+  assert.match(sql, /ADD CONSTRAINT store_module_prices_no_new_credit_price CHECK \(price_credits IS NULL\) NOT VALID;/);
+  assert.match(sql, /DROP CONSTRAINT IF EXISTS store_module_prices_no_new_credit_price;/, 'idempotent on a re-run');
+  assert.doesNotMatch(sql, /VALIDATE CONSTRAINT|UPDATE store_module_prices|DELETE FROM store_module_prices/,
+    'no old row is validated, rewritten or deleted');
+});
+
 test('a version is exact semver and can be published only once per module', () => {
   const t = table('store_module_versions');
   assert.match(t, /version\s+text NOT NULL\s+CHECK \(version ~ '\^\[0-9\]\+\\\.\[0-9\]\+\\\.\[0-9\]\+\$'\)/);