@bongos/core 1.23.22 → 1.24.1

package/tests/market_watch_data_db.mjs

@@ -0,0 +1,308 @@
+// tests/market_watch_data_db.mjs — the Market Watch tables, seed and read queries against a
+// REAL Postgres (task 1004936, goal 1000137).
+//
+// What only a real engine can say: the migration applies, and applies again as a no-op;
+// the hub seed loads 60 items and loads again inserting nothing; the CHECKs and partial
+// unique indexes refuse the rows they exist to refuse (an unsourced entry, a done item with
+// no cost, a skipped run with no reason, a second active rules version, a second seed run);
+// and the read queries return the levels, streaks, run numbers, sparklines, spend and
+// resume set the screens and the weekly run need.
+//
+// The module is default:false, so CI's migrate.sh does not apply its migrations; this file
+// applies market_watch_001 itself (twice). Its rows live under a project origin no real
+// instance has and are deleted before and after. Real-DB integration test: self-skips
+// without a reachable Postgres; in the INTEGRATION set (scripts/bongos/run-unit-tests.js)
+// so the DB-free lane never runs it. The DB-free half is tests/market_watch_data.mjs.
+//
+// Run:  DATABASE_URL=... node tests/market_watch_data_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 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 run = require('../modules/market-watch/run.js');
+const store = require('../modules/market-watch/store.js');
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`market_watch_data_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+const P = 'https://t1004936-hub.example';
+const OTHER = 'https://t1004936-other.example';
+const ALICE = 91004936, BOB = 91004937;
+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_score_snapshots WHERE item_id IN (SELECT id FROM market_watch_items WHERE project = $1)`, [project]).catch(() => {});
+    await q(`DELETE FROM market_watch_log_entries WHERE item_id IN (SELECT id FROM market_watch_items WHERE project = $1)`, [project]).catch(() => {});
+    await q(`DELETE FROM market_watch_run_items WHERE run_id IN (SELECT id FROM market_watch_runs WHERE project = $1)`, [project]).catch(() => {});
+    await q(`DELETE FROM market_watch_runs 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 market_watch_settings WHERE project = $1`, [project]).catch(() => {});
+  }
+  await q(`DELETE FROM builders WHERE id = ANY($1::bigint[])`, [[ALICE, BOB]]).catch(() => {});
+}
+
+// A statement that must be refused by the schema. Each runs in its own SAVEPOINT-free
+// autocommit statement, so a refusal leaves nothing behind.
+async function refused(sql, params, why) {
+  await assert.rejects(q(sql, params), /violates|invalid input/, why);
+}
+
+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 check('the migration applies, and applies again as a no-op', async () => {
+    await q(MIGRATION);
+    await q(MIGRATION);
+    // market_watch_002 (task 1004937): the run's key columns, one-open-run index and the
+    // 'run' proposal origin. A new migration here joins this file (CI never applies it).
+    await q(MIGRATION_002);
+    await q(MIGRATION_002);
+    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}`);
+  });
+  await cleanup();
+  await insertTestBuilders(pool, [{ id: ALICE, login: 't1004936-alice' }, { id: BOB, login: 't1004936-bob' }]);
+
+  await check('the seed loads off the hub never, on the hub once, and a second load inserts nothing', async () => {
+    assert.equal((await seed.seedHub({ pool, isHub: false, project: OTHER })).skipped, 'not_hub');
+    const first = await seed.seedHub({ pool, isHub: true, project: P });
+    assert.equal(first.seeded, true);
+    assert.equal(first.inserted.items, 60);
+    assert.equal(first.inserted.scores, 360);
+    assert.equal(first.inserted.runs, 1);
+    assert.equal(first.inserted.rules, 1);
+    assert.ok(first.inserted.entries > 60);
+    const again = await seed.seedHub({ pool, isHub: true, project: P });
+    assert.deepEqual(again.inserted, { rules: 0, runs: 0, items: 0, scores: 0, entries: 0 });
+    const { rows: [n] } = await q(`SELECT count(*)::int AS items, count(*) FILTER (WHERE kind = 'competitor')::int AS comps
+                                     FROM market_watch_items WHERE project = $1`, [P]);
+    assert.deepEqual(n, { items: 60, comps: 36 });
+    assert.equal((await db.listItems(pool, { project: OTHER })).length, 0, 'nothing reached the other project');
+  });
+
+  await check('a removed item stays removed when the seed runs again', async () => {
+    await q(`UPDATE market_watch_items SET status = 'removed' WHERE project = $1 AND name = 'Sweep'`, [P]);
+    await seed.seedHub({ pool, isHub: true, project: P });
+    const items = await db.listItems(pool, { project: P });
+    assert.equal(items.length, 59);
+    assert.ok(!items.some((i) => i.name === 'Sweep'));
+    assert.equal((await db.listItems(pool, { project: P, includeRemoved: true })).length, 60);
+  });
+
+  const { rows: [{ id: seedRun }] } = await q(`SELECT id FROM market_watch_runs WHERE project = $1 AND trigger = 'seed'`, [P]);
+  const { rows: [{ id: rule1 }] } = await q(`SELECT id FROM market_watch_rule_versions WHERE project = $1 AND version = 1`, [P]);
+  const { rows: [copilot] } = await q(`SELECT id FROM market_watch_items WHERE project = $1 AND name = 'GitHub Copilot coding agent'`, [P]);
+
+  await check('seeded items read at level 1, streak 1, with their overall score and case file', async () => {
+    const items = await db.listItems(pool, { project: P, kind: 'competitor' });
+    assert.equal(items.length, 35);
+    const c = items.find((i) => i.id === Number(copilot.id));
+    assert.equal(c.level, 1);
+    assert.equal(c.streak, 1);
+    assert.equal(typeof c.overall, 'number');
+    const file = await db.caseFile(pool, { project: P, itemId: copilot.id });
+    assert.ok(file.length >= 1);
+    for (const e of file) { assert.equal(e.run, 1); assert.match(e.source_url, /^https?:\/\//); }
+    assert.equal(await db.getItem(pool, { project: OTHER, id: copilot.id }), null, 'another project cannot read it');
+  });
+
+  // A skipped run, then a real one that finds something on Copilot and re-scores it.
+  const { rows: [{ id: skipped }] } = await q(
+    `INSERT INTO market_watch_runs (project, status, reason, trigger, created_at) VALUES ($1, 'skipped', 'cap_reached', 'poller', '2026-11-04T09:00:00Z') RETURNING id`, [P]);
+  const { rows: [{ id: run2 }] } = await q(
+    `INSERT INTO market_watch_runs (project, status, trigger, rule_version_id, started_at, finished_at, created_at)
+     VALUES ($1, 'done', 'poller', $2, now(), now(), '2026-11-11T09:00:00Z') RETURNING id`, [P, rule1]);
+  await q(`INSERT INTO market_watch_run_items (run_id, item_id, status, cost_usd, finished_at) VALUES ($1, $2, 'done', 0.0950, '2026-11-11T09:05:00Z')`, [run2, copilot.id]);
+  await q(`INSERT INTO market_watch_log_entries (item_id, run_id, type, takeaway, source_url, confidence) VALUES ($1, $2, 'news', 'Agent mode reaches self-hosted Enterprise Server.', 'https://github.blog/x', 3)`, [copilot.id, run2]);
+  await q(`INSERT INTO market_watch_score_snapshots (item_id, run_id, dimension, value) VALUES ($1, $2, 'overall', 7), ($1, $2, 'human_gates', 8)`, [copilot.id, run2]);
+
+  await check('a later run levels the item up, a skipped run takes no number and breaks no streak', async () => {
+    const c = await db.getItem(pool, { project: P, id: copilot.id });
+    assert.deepEqual([c.level, c.streak, c.overall], [2, 2, 7]);
+    const other = (await db.listItems(pool, { project: P })).find((i) => i.name === 'Cursor (Anysphere)');
+    assert.deepEqual([other.level, other.streak], [1, 0], 'nothing found on it in the latest run');
+    const runs = await db.numberedRuns(pool, { project: P });
+    assert.deepEqual(runs.map((r) => [Number(r.id), r.n]), [[Number(seedRun), 1], [Number(skipped), null], [Number(run2), 2]]);
+    const file = await db.caseFile(pool, { project: P, itemId: copilot.id });
+    assert.equal(file[0].run, 2, 'newest first');
+  });
+
+  await check('the sparklines align on the runs that scored the item', async () => {
+    const h = await db.scoreHistory(pool, { project: P, itemId: copilot.id });
+    assert.deepEqual(h.runs.map((r) => r.n), [1, 2]);
+    assert.equal(h.series.overall[1], 7);
+    assert.equal(h.series.human_gates.length, 2);
+    assert.equal(h.series.ai_agents_write_code[1], null, 'not scored in run 2: null, never carried forward');
+  });
+
+  await check('a resumed run is offered only the items it has not done', async () => {
+    const left = await db.remainingItems(pool, { project: P, runId: run2 });
+    assert.equal(left.length, 58, '59 active minus the one done');
+    assert.ok(!left.some((i) => i.id === Number(copilot.id)));
+    assert.deepEqual(await db.remainingItems(pool, { project: OTHER, runId: run2 }), [], 'another project cannot read the run');
+  });
+
+  await check('settings read the defaults, then the row, with this month spend and the skipped run on the strip', async () => {
+    let v = await db.settingsView(pool, { project: P, now: new Date('2026-11-20T00:00:00Z') });
+    assert.equal(v.settings.configured, false);
+    assert.equal(v.settings.enabled, false);
+    assert.equal(v.spentThisMonthUsd, 0.095);
+    assert.deepEqual(v.recentRuns.map((r) => [r.status, r.reason]), [['done', null], ['skipped', 'cap_reached']], 'the seed run is not on the strip');
+    assert.equal(v.recentRuns[0].items_done, 1);
+    assert.equal(v.nextRunDue.toISOString(), '2026-11-18T09:00:00.000Z');
+    await q(`INSERT INTO market_watch_settings (project, enabled, monthly_cap_usd, cadence, updated_by) VALUES ($1, true, 25, 'biweekly', $2)`, [P, ALICE]);
+    v = await db.settingsView(pool, { project: P, now: new Date('2026-12-02T00:00:00Z') });
+    assert.deepEqual([v.settings.enabled, v.settings.monthly_cap_usd, v.settings.cadence], [true, 25, 'biweekly']);
+    assert.equal(v.spentThisMonthUsd, 0, 'a new month starts at zero');
+  });
+
+  await check('rules: one active, one proposed next, and the history in order', async () => {
+    const { rows: [{ id: v2 }] } = await q(
+      `INSERT INTO market_watch_rule_versions (project, version, status, rubric, summary, reason, author_id)
+       VALUES ($1, 2, 'proposed', '{}'::jsonb, '+ bounty boards', 'finds Algora and Opire', $2) RETURNING id`, [P, BOB]);
+    const r = await db.rules(pool, { project: P });
+    assert.deepEqual(r.versions.map((v) => [v.version, v.status]), [[1, 'active'], [2, 'proposed']]);
+    assert.equal(r.active.version, 1);
+    assert.equal(r.proposed.id, Number(v2));
+    assert.equal(r.active.rubric.competitor.length, 5);
+    await refused(`INSERT INTO market_watch_rule_versions (project, version, status, reason) VALUES ($1, 3, 'proposed', 'x')`, [P], 'a second proposed version');
+    await refused(`INSERT INTO market_watch_rule_versions (project, version, status, reason) VALUES ($1, 3, 'active', 'x')`, [P], 'a second active version');
+    await q(`INSERT INTO market_watch_proposals (project, kind, origin, rule_version_id, reason, proposed_by) VALUES ($1, 'rule_change', 'member', $2, 'count bounty boards', $3)`, [P, v2, BOB]);
+  });
+
+  await check('a weekly ask pools taps into tallies and proposals, and the member streak reads', async () => {
+    const ins = async (week, closes) => (await q(
+      `INSERT INTO market_watch_weekly_asks (project, week_of, question_key, prompt, options, closes_at)
+       VALUES ($1, $2, 'rival', 'What counts as a competitor?', '[{"label":"AI IDEs"}]'::jsonb, $3) RETURNING id`, [P, week, closes])).rows[0].id;
+    const w1 = await ins('2026-11-02', '2026-11-08T00:00:00Z');
+    const w2 = await ins('2026-11-09', '2026-11-15T00:00:00Z');
+    const w3 = await ins('2026-11-16', '2099-01-01T00:00:00Z');
+    const tap = async (ask, who, choice) => (await q(
+      `INSERT INTO market_watch_ask_answers (ask_id, builder_id, choice) VALUES ($1, $2, $3) RETURNING id`, [ask, who, choice])).rows[0].id;
+    await tap(w1, ALICE, 'AI IDEs');
+    await tap(w2, ALICE, 'AI IDEs');
+    const a = await tap(w2, BOB, 'AI IDEs');
+    await tap(w2, BOB, 'Bounty boards');
+    await refused(`INSERT INTO market_watch_ask_answers (ask_id, builder_id, choice) VALUES ($1, $2, 'AI IDEs')`, [w2, BOB], 'a second tap on the same chip');
+    const week = await db.weeklyAsk(pool, { project: P, weekOf: '2026-11-09' });
+    assert.deepEqual(week[0].tallies, [{ choice: 'AI IDEs', taps: 2 }, { choice: 'Bounty boards', taps: 1 }]);
+    assert.equal(await db.askStreak(pool, { project: P, builderId: ALICE, now: new Date('2026-11-17T00:00:00Z') }), 2, 'w3 is open: not yet a miss');
+    assert.equal(await db.askStreak(pool, { project: P, builderId: BOB, now: new Date('2026-11-17T00:00:00Z') }), 1);
+    await q(`INSERT INTO market_watch_proposals (project, kind, origin, answer_id, payload, proposed_by) VALUES ($1, 'add_item', 'weekly_ask', $2, '{"name":"Cursor"}'::jsonb, $3)`, [P, a, BOB]);
+    await refused(`INSERT INTO market_watch_proposals (project, kind, origin, answer_id, payload) VALUES ($1, 'add_item', 'weekly_ask', $2, '{}'::jsonb)`, [P, a], 'one tap is one proposal');
+    const open = await db.proposals(pool, { project: P });
+    assert.deepEqual(open.map((p) => p.kind).sort(), ['add_item', 'rule_change']);
+    assert.equal(w3 > 0, true);
+  });
+
+  await check('the schema refuses what its rules forbid', async () => {
+    await refused(`INSERT INTO market_watch_log_entries (item_id, run_id, type, takeaway, source_url, confidence) VALUES ($1, $2, 'news', 'no source', '', 2)`, [copilot.id, run2], 'an unsourced entry');
+    await refused(`INSERT INTO market_watch_log_entries (item_id, run_id, type, takeaway, source_url, confidence) VALUES ($1, $2, 'news', 'too sure', 'https://x.example', 4)`, [copilot.id, run2], 'confidence above 3');
+    await refused(`INSERT INTO market_watch_log_entries (item_id, run_id, type, takeaway, source_url, confidence) VALUES ($1, $2, 'news', 'Agent mode reaches self-hosted Enterprise Server.', 'https://github.blog/y', 3)`, [copilot.id, run2], 'the same takeaway twice in one run (a resumed item)');
+    await refused(`INSERT INTO market_watch_run_items (run_id, item_id, status) VALUES ($1, $2, 'done')`, [run2, (await q(`SELECT id FROM market_watch_items WHERE project = $1 AND name = 'Factory'`, [P])).rows[0].id], 'done with no cost');
+    await refused(`INSERT INTO market_watch_run_items (run_id, item_id, status, cost_usd) VALUES ($1, $2, 'done', 0.1)`, [run2, copilot.id], 'the same item twice in a run');
+    await refused(`INSERT INTO market_watch_runs (project, status, trigger) VALUES ($1, 'skipped', 'poller')`, [P], 'a skipped run with no reason');
+    await refused(`INSERT INTO market_watch_runs (project, status, trigger) VALUES ($1, 'done', 'seed')`, [P], 'a second seed run');
+    await refused(`INSERT INTO market_watch_score_snapshots (item_id, run_id, dimension, value) VALUES ($1, $2, 'overall', 11)`, [copilot.id, skipped], 'a score above 10');
+    await refused(`INSERT INTO market_watch_proposals (project, kind, origin) VALUES ($1, 'rescore', 'member')`, [P], 'a rescore that names no item');
+    await refused(`INSERT INTO market_watch_settings (project, cadence) VALUES ($1, 'daily')`, [OTHER], 'an unknown cadence');
+  });
+
+  // The weekly run (task 1004937) through the REAL store on the seeded project: a fake
+  // Messages API client (no network, no key spent) answers every item with two sourced
+  // entries, two scores and one candidate.
+  await check('the weekly run on seed data writes sourced entries, score snapshots, one proposal, and the cost', async () => {
+    const NEWS = 'https://news.example.com/launch';
+    const answer = {
+      stop_reason: 'end_turn',
+      content: [
+        { type: 'web_search_tool_result', tool_use_id: 's1', content: [{ type: 'web_search_result', url: NEWS }] },
+        { type: 'text', text: JSON.stringify({
+          entries: [
+            { type: 'news', takeaway: 'Shipped a self-hosted agent.', source_url: NEWS, source_label: 'news', confidence: 'high', dimension: null },
+            { type: 'news', takeaway: 'Unsourced.', source_url: 'https://invented.example/x', source_label: '', confidence: 'high', dimension: null },
+          ],
+          scores: [{ dimension: 'overall', value: 6, reason: 'Moved closer.' }],
+          candidates: [{ name: 'Newco Agents', url: 'https://newco.example.com', kind: 'competitor', why: 'Named in the launch.' }],
+        }) },
+      ],
+      usage: { input_tokens: 20000, output_tokens: 1500, server_tool_use: { web_search_requests: 2 } },
+    };
+    const keys = [];
+    const mirrored = [];
+    const d = {
+      project: P,
+      store: store.createStore(pool),
+      now: () => Date.parse('2027-01-10T10:00:00Z'), // well past run2, in a month with no spend
+      readKey: async () => 'sk-ant-test-not-a-real-key-WXYZ',
+      createClient: (k) => { keys.push(k); return { messages: { create: async () => answer } }; },
+      economy: { logCost: async (row) => { mirrored.push(row); } },
+      warn: () => {},
+    };
+    const r = await run.runDue(d);
+    assert.equal(r.outcome, 'done', JSON.stringify(r));
+    assert.deepEqual(keys, ['sk-ant-test-not-a-real-key-WXYZ']);
+    const { rows: [runRow] } = await q(`SELECT status, reason, claimed_until FROM market_watch_runs WHERE id = $1`, [r.runId]);
+    assert.deepEqual([runRow.status, runRow.reason, runRow.claimed_until], ['done', null, null]);
+    const { rows: [n] } = await q(
+      `SELECT (SELECT count(*)::int FROM market_watch_log_entries WHERE run_id = $1) AS entries,
+              (SELECT count(*)::int FROM market_watch_log_entries WHERE run_id = $1 AND source_url <> $2) AS unsourced,
+              (SELECT count(*)::int FROM market_watch_score_snapshots WHERE run_id = $1 AND reason = 'Moved closer.') AS scores,
+              (SELECT count(*)::int FROM market_watch_proposals WHERE run_id = $1 AND origin = 'run' AND kind = 'add_item') AS proposals,
+              (SELECT count(*)::int FROM market_watch_run_items WHERE run_id = $1 AND status = 'done' AND cost_usd = 0.075) AS items`,
+      [r.runId, NEWS]);
+    assert.equal(n.entries, r.done, 'one sourced entry per item; the invented link never landed');
+    assert.equal(n.unsourced, 0);
+    assert.equal(n.scores, r.done);
+    assert.equal(n.proposals, 1, 'one proposal per candidate per run, and no new item');
+    assert.equal(n.items, r.done);
+    assert.equal((await q(`SELECT count(*)::int AS n FROM market_watch_items WHERE project = $1 AND name = 'Newco Agents'`, [P])).rows[0].n, 0);
+    assert.equal(mirrored.length, r.done);
+    assert.ok(mirrored.every((m) => m.source === `market-watch:${r.runId}` && m.category === 'api' && m.amountUsd === 0.075));
+    // Recorded once: a second write of a finished item changes nothing.
+    const itemId = (await q(`SELECT item_id FROM market_watch_run_items WHERE run_id = $1 LIMIT 1`, [r.runId])).rows[0].item_id;
+    assert.equal((await store.recordItem(pool, P, r.runId, itemId, { ok: false, error: 'x', costUsd: 1 })).recorded, false);
+    // Never another project's: the same run and item under another project key writes nothing.
+    await assert.rejects(store.recordItem(pool, OTHER, r.runId, itemId, { ok: true, entries: [], scores: [], candidates: [], costUsd: 0 }), /cross_project/);
+    // The run left no open row behind for the next tick to resume.
+    assert.equal(await store.openRun(pool, P), null);
+  });
+
+  await check('one open run per project, and the key must be a secret-box blob', async () => {
+    await q(`INSERT INTO market_watch_runs (project, status, trigger) VALUES ($1, 'queued', 'manual')`, [OTHER]);
+    await refused(`INSERT INTO market_watch_runs (project, status, trigger) VALUES ($1, 'running', 'poller')`, [OTHER], 'a second open run');
+    await refused(`INSERT INTO market_watch_settings (project, anthropic_key_enc, anthropic_key_last4) VALUES ($1, 'sk-ant-plaintext', 'text')`, [OTHER], 'a plaintext key');
+  });
+} finally {
+  await cleanup();
+  await pool.end();
+}
+
+if (failed) {
+  console.log(`market_watch_data_db.mjs: ${failed} failed`);
+  process.exit(1);
+}
+console.log('market_watch_data_db.mjs: all passed');

package/tests/market_watch_module.mjs

@@ -0,0 +1,114 @@
+// tests/market_watch_module.mjs — the market-watch module is registered, accepted by
+// 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
+// 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;
+//   2. the loader discovers it from the live tree with no error and no skip;
+//   3. the resolved module set has it OFF with no config, and the spend guard refuses
+//      to turn it on behind an open join door with no payer;
+//   4. the real platform app boots and its hall reports market-watch present and false;
+//   5. the creation picker does not offer it while it does nothing.
+import assert from 'node:assert/strict';
+import { test, before, after } from 'node:test';
+import http from 'node:http';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const KEY = 'market-watch';
+const manifest = JSON.parse(readFileSync(new URL('../modules/market-watch/module.json', import.meta.url), 'utf8'));
+const { validateManifest } = require('../src/module-loader/manifest-schema.js');
+const loader = require('../src/module-loader/loader.js');
+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', () => {
+  const v = validateManifest(manifest);
+  assert.equal(v.valid, true, `manifest errors: ${v.errors.join('; ')}`);
+  assert.equal(manifest.key, KEY);
+  assert.equal(manifest.default, false, 'shipped is not enabled (ADR 0083)');
+  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');
+});
+
+test('the loader discovers it from the live tree — loaded, not an error, not skipped', () => {
+  loader._reset();
+  const snap = loader.loaderSnapshot();
+  assert.ok(snap.loaded.includes(KEY), `loaded: ${snap.loaded.join(', ')}`);
+  assert.deepEqual(snap.errors.filter((e) => JSON.stringify(e).includes(KEY)), []);
+  assert.deepEqual(snap.skipped.filter((s) => JSON.stringify(s).includes(KEY)), []);
+  const reg = loader.discoveredRegistry();
+  assert.equal(reg[KEY].default, false);
+  assert.equal(mods.metersSpend(reg[KEY]), true, 'the declaration rides through the loader to the spend guard');
+  loader._reset();
+});
+
+test('with no config it resolves OFF, and isModuleEnabled answers rather than throwing "unknown module"', () => {
+  mods._resetForTests && mods._resetForTests();
+  assert.ok(mods.knownModules().includes(KEY));
+  const set = mods.resolveModules({ registry: mods.effectiveRegistry() });
+  assert.equal(set[KEY], false);
+  assert.equal(mods.isModuleEnabled(KEY, set), false);
+});
+
+test('the spend guard bites it: an open door with no payer cannot enable it; a closed door can', () => {
+  const registry = mods.effectiveRegistry();
+  const on = { modules: { [KEY]: true } };
+  const silent = () => {};
+  assert.equal(mods.resolveModules({ instance: on, registry, spendGuard: { joinDoorOpen: true, payer: null }, warn: silent })[KEY], false);
+  assert.equal(mods.resolveModules({ instance: on, registry, spendGuard: { joinDoorOpen: false, payer: null }, warn: silent })[KEY], true);
+});
+
+test('it has a scope-roster key, and the creation picker does not offer it while it is empty', () => {
+  assert.ok(Array.isArray(scopeMap.MODULE_GLOBS[KEY]) && scopeMap.MODULE_GLOBS[KEY].includes('modules/market-watch/'));
+  // Every entry is an exact path or a dir prefix (the touches[] convention has no
+  // wildcards), and this test's own path resolves to the module's scope.
+  for (const g of scopeMap.MODULE_GLOBS[KEY]) assert.ok(!g.includes('*'), `wildcard glob never matches: ${g}`);
+  assert.ok(scopeMap.MODULE_GLOBS[KEY].includes('tests/market_watch_module.mjs'));
+  assert.ok(bundles.HUB_ONLY_MODULES.includes(KEY));
+  assert.ok(!bundles.OPTIONAL_MODULES.some((m) => m.key === KEY));
+  assert.ok(!bundles.ALWAYS_ON_CORE.includes(KEY));
+});
+
+// --- an instance boots with it present and disabled -------------------------
+let server;
+let port;
+before(async () => {
+  loader._reset();
+  mods._resetForTests && mods._resetForTests();
+  const { buildPlatformApp } = require('../src/platform-server.js');
+  server = http.createServer(buildPlatformApp());
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  port = server.address().port;
+});
+after(async () => { if (server) await new Promise((resolve) => server.close(resolve)); });
+
+function get(pathname, host) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({ host: '127.0.0.1', port, path: pathname, method: 'GET', headers: { Host: host } }, (res) => {
+      let body = '';
+      res.on('data', (c) => (body += c));
+      res.on('end', () => resolve({ status: res.statusCode, body }));
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+test('the platform boots and its hall reports market-watch present and OFF', async () => {
+  const res = await get('/', 'builders.test.local');
+  assert.equal(res.status, 200);
+  const m = res.body.match(/window\.__MODULES__=(\{.*?\});/);
+  assert.ok(m, 'a __MODULES__ assignment is present');
+  const enabled = JSON.parse(m[1]).enabled;
+  assert.ok(Object.prototype.hasOwnProperty.call(enabled, KEY), 'present: the booted instance knows the key');
+  assert.equal(enabled[KEY], false, 'disabled');
+});