@bongos/core 1.23.21 → 1.24.1

package/tests/market_watch_data.mjs

@@ -0,0 +1,244 @@
+// tests/market_watch_data.mjs — the Market Watch data layer without a database (task
+// 1004936, goal 1000137): the seed built from the committed research files, the hub-only
+// and idempotent seed write, the pure derivations behind levels, streaks, sparklines and
+// the settings gauge, the read queries' project scoping, and the migration's own rules.
+//
+// The SQL itself runs against a real Postgres in tests/market_watch_data_db.mjs (the
+// INTEGRATION set); this file is the DB-free half and runs in the unit lane.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const seed = require('../modules/market-watch/seed.js');
+const db = require('../modules/market-watch/db.js');
+const hubSeed = require('../modules/market-watch/pollers/hub-seed.js');
+const MIGRATION = readFileSync(new URL('../modules/market-watch/migrations/market_watch_001_tables.sql', import.meta.url), 'utf8');
+
+const market = seed.readSeed('market-data.json');
+const partners = seed.readSeed('partners-data.json');
+const built = seed.buildSeed({ market, partners });
+
+// A pool that records every statement and answers each SELECT … id with one row.
+function fakePool({ failOn = null } = {}) {
+  const calls = [];
+  let id = 0;
+  const client = {
+    async query(sql, params = []) {
+      calls.push({ sql, params });
+      if (failOn && failOn.test(sql)) throw new Error('boom');
+      if (/^\s*SELECT id FROM/.test(sql)) return { rows: [{ id: ++id }], rowCount: 1 };
+      return { rows: [], rowCount: 1 };
+    },
+    release() { calls.push({ sql: 'RELEASE' }); },
+  };
+  return { calls, pool: { connect: async () => client, query: client.query } };
+}
+
+test('the seed carries all 36 researched companies and all 24 partners, scored and sourced', () => {
+  assert.equal(market.length, 36);
+  assert.equal(partners.length, 24);
+  const comps = built.items.filter((i) => i.kind === 'competitor');
+  const parts = built.items.filter((i) => i.kind === 'partner');
+  assert.equal(comps.length, 36);
+  assert.equal(parts.length, 24);
+  for (const it of built.items) {
+    const rubricKeys = seed.RUBRIC[it.kind].map((d) => d.key);
+    assert.deepEqual(Object.keys(it.scores).sort(), [...rubricKeys, 'overall'].sort(), `${it.name}: five rubric dimensions plus overall`);
+    for (const v of Object.values(it.scores)) assert.ok(v >= 0 && v <= 10, `${it.name}: ${v}`);
+    assert.ok(it.entries.length >= 1, `${it.name} has a case file`);
+    for (const e of it.entries) {
+      assert.match(e.sourceUrl, /^https?:\/\//, `${it.name}: every entry has a source`);
+      assert.ok([1, 2, 3].includes(e.confidence));
+      assert.ok(['insight', 'news', 'datapoint'].includes(e.type));
+    }
+  }
+  // The item key the migration enforces is unique across the seed, so no row is lost to it.
+  assert.equal(new Set(built.items.map((i) => `${i.kind}|${i.url}|${i.name}`)).size, 60);
+  // An unverified claim is never seeded as better than low confidence.
+  const unverified = built.items.flatMap((i) => i.entries).filter((e) => /unverified/i.test(e.takeaway));
+  assert.ok(unverified.length > 0);
+  for (const e of unverified) assert.equal(e.confidence, 1, e.takeaway);
+});
+
+test('the rules seed as version 1 with both rubrics, defined', () => {
+  assert.equal(built.rules.version, 1);
+  for (const kind of ['competitor', 'partner']) {
+    assert.equal(built.rules.rubric[kind].length, 5);
+    for (const d of built.rules.rubric[kind]) assert.ok(d.label && d.definition && d.weight > 0, JSON.stringify(d));
+  }
+  assert.ok(built.rules.searchQueries.length > 0 && built.rules.sources.length > 0 && built.rules.instructions.length > 0);
+});
+
+test('projectKey is the public origin, normalised, and refuses anything else', () => {
+  assert.equal(seed.projectKey('https://CloudBongos.com/'), 'https://cloudbongos.com');
+  assert.equal(seed.projectKey('http://localhost:3000'), 'http://localhost:3000');
+  for (const bad of ['', null, 'cloudbongos.com', 'https://x.com/path', 'ftp://x.com']) assert.equal(seed.projectKey(bad), null, String(bad));
+});
+
+test('the seed writes nothing off the hub, or with no origin', async () => {
+  const { pool, calls } = fakePool();
+  assert.deepEqual(await seed.seedHub({ pool, isHub: false, project: 'https://hub.example' }), { seeded: false, skipped: 'not_hub' });
+  assert.deepEqual(await seed.seedHub({ pool, isHub: 'true', project: 'https://hub.example' }), { seeded: false, skipped: 'not_hub' });
+  assert.deepEqual(await seed.seedHub({ pool, isHub: true, project: 'not an origin' }), { seeded: false, skipped: 'no_project_origin' });
+  assert.equal(calls.length, 0, 'not one statement');
+});
+
+test('on the hub it writes in one transaction, every insert idempotent and scoped to the project', async () => {
+  const { pool, calls } = fakePool();
+  const r = await seed.seedHub({ pool, isHub: true, project: 'https://Hub.example/' });
+  assert.equal(r.seeded, true);
+  assert.equal(r.project, 'https://hub.example');
+  assert.equal(calls[0].sql, 'BEGIN');
+  assert.equal(calls.at(-2).sql, 'COMMIT');
+  assert.equal(calls.at(-1).sql, 'RELEASE');
+  const inserts = calls.filter((c) => /^\s*INSERT/.test(c.sql));
+  assert.equal(inserts.length, 1 + 1 + 60 + 360 + built.items.reduce((a, i) => a + i.entries.length, 0));
+  for (const c of inserts) assert.match(c.sql, /ON CONFLICT .* DO NOTHING/s, c.sql);
+  for (const c of calls.filter((x) => /market_watch_(items|runs|rule_versions)/.test(x.sql) && x.params)) {
+    assert.equal(c.params[0], 'https://hub.example', 'project is $1 on every project-owned row');
+  }
+  // No person is invented: no seed statement writes an author, approver or adder.
+  for (const c of inserts) assert.doesNotMatch(c.sql, /author_id|approved_by|added_by|proposed_by/);
+});
+
+test('a failed write rolls back and releases', async () => {
+  const { pool, calls } = fakePool({ failOn: /INSERT INTO market_watch_score_snapshots/ });
+  await assert.rejects(seed.seedHub({ pool, isHub: true, project: 'https://hub.example' }), /boom/);
+  assert.ok(calls.some((c) => c.sql === 'ROLLBACK'));
+  assert.ok(!calls.some((c) => c.sql === 'COMMIT'));
+  assert.equal(calls.at(-1).sql, 'RELEASE');
+});
+
+test('the boot poller never throws into the server and counts a failure', async () => {
+  let reported = 0;
+  const r = await hubSeed.runOnce({ seedHub: async () => { throw new Error('db down'); }, reportError: () => { reported += 1; } });
+  assert.equal(r.seeded, false);
+  assert.equal(reported, 1);
+  const ok = await hubSeed.runOnce({ seedHub: async () => ({ seeded: false, skipped: 'not_hub' }) });
+  assert.equal(ok.skipped, 'not_hub');
+});
+
+// ---- the derivations ------------------------------------------------------
+
+const RUNS = [
+  { id: 4, status: 'done', created_at: '2026-11-11T00:00:00Z' },
+  { id: 1, status: 'done', created_at: '2026-10-28T00:00:00Z' },
+  { id: 3, status: 'skipped', created_at: '2026-11-07T00:00:00Z' },
+  { id: 2, status: 'partial', created_at: '2026-11-04T00:00:00Z' },
+];
+
+test('runs are numbered oldest first, and a run that never ran takes no number', () => {
+  const n = db.numberRuns(RUNS);
+  assert.deepEqual(n.map((r) => [r.id, r.n]), [[1, 1], [2, 2], [3, null], [4, 3]]);
+});
+
+test('level counts the runs that found something; streak counts the latest ones in a row', () => {
+  const n = db.numberRuns(RUNS);
+  assert.deepEqual(db.progress(n, []), { level: 1, streak: 0 }, 'a tracked item is level 1');
+  assert.deepEqual(db.progress(n, [1, 2, 4]), { level: 3, streak: 3 }, 'a skipped run does not break a streak');
+  assert.deepEqual(db.progress(n, [1, 4]), { level: 2, streak: 1 });
+  assert.deepEqual(db.progress(n, [1, 2]), { level: 2, streak: 0 }, 'nothing in the latest run');
+  assert.deepEqual(db.progress(n, ['4']), { level: 1, streak: 1 }, 'ids compare as strings (pg bigint)');
+});
+
+test('sparklines: one point per run that scored the item, null where a dimension was not scored', () => {
+  const n = db.numberRuns(RUNS);
+  const s = db.sparklines([
+    { run_id: 1, dimension: 'overall', value: '5.0' }, { run_id: 1, dimension: 'human_gates', value: '6' },
+    { run_id: 4, dimension: 'overall', value: '6.0' },
+    { run_id: 99, dimension: 'overall', value: '9' },
+  ], n);
+  assert.deepEqual(s.runs.map((r) => r.n), [1, 3]);
+  assert.deepEqual(s.series, { overall: [5, 6], human_gates: [6, null] });
+});
+
+test('the ask streak counts answered weeks back from the newest; an open unanswered week does not break it', () => {
+  assert.equal(db.weekStreak([{ id: 'w4', open: true }, { id: 'w3' }, { id: 'w2' }, { id: 'w1' }], ['w3', 'w2']), 2);
+  assert.equal(db.weekStreak([{ id: 'w4', open: false }, { id: 'w3' }], ['w3']), 0, 'a closed missed week breaks it');
+  assert.equal(db.weekStreak([{ id: 'w4', open: true }, { id: 'w3' }], ['w4', 'w3']), 2);
+  assert.equal(db.weekStreak([], []), 0);
+});
+
+test('the next run is due one cadence after the last; no run yet means due now', () => {
+  assert.equal(db.nextRunDue(null, 'weekly'), null);
+  assert.equal(db.nextRunDue('2026-11-01T09:00:00Z', 'weekly').toISOString(), '2026-11-08T09:00:00.000Z');
+  assert.equal(db.nextRunDue('2026-11-01T09:00:00Z', 'biweekly').toISOString(), '2026-11-15T09:00:00.000Z');
+  assert.throws(() => db.nextRunDue('2026-11-01T09:00:00Z', 'daily'), /unknown cadence/);
+  const [a, b] = db.monthBounds(new Date('2026-12-31T23:59:00Z'));
+  assert.equal(a.toISOString(), '2026-12-01T00:00:00.000Z');
+  assert.equal(b.toISOString(), '2027-01-01T00:00:00.000Z');
+});
+
+// ---- the reads are project-scoped ----------------------------------------
+
+test('every read refuses a missing project and passes it as $1', async () => {
+  const seen = [];
+  const pool = {
+    async query(sql, params) {
+      seen.push({ sql, params });
+      if (/sum\(ri\.cost_usd\), 0\) AS spent/.test(sql)) return { rows: [{ spent: '0' }] };
+      return { rows: [] };
+    },
+  };
+  const P = 'https://hub.example';
+  const reads = [
+    () => db.listItems(pool, { project: P }),
+    () => db.getItem(pool, { project: P, id: 1 }),
+    () => db.caseFile(pool, { project: P, itemId: 1 }),
+    () => db.scoreHistory(pool, { project: P, itemId: 1 }),
+    () => db.rules(pool, { project: P }),
+    () => db.proposals(pool, { project: P }),
+    () => db.weeklyAsk(pool, { project: P, weekOf: '2026-11-02' }),
+    () => db.askStreak(pool, { project: P, builderId: 1 }),
+    () => db.settingsView(pool, { project: P }),
+    () => db.remainingItems(pool, { project: P, runId: 1 }),
+  ];
+  for (const r of reads) await r();
+  assert.ok(seen.length >= reads.length);
+  for (const s of seen) {
+    assert.equal(s.params[0], P, s.sql);
+    assert.match(s.sql, /project = \$1/, s.sql);
+  }
+  for (const fn of ['listItems', 'caseFile', 'scoreHistory', 'rules', 'proposals', 'weeklyAsk', 'settingsView', 'remainingItems']) {
+    await assert.rejects(db[fn](pool, {}), /project key is required/, fn);
+  }
+  const v = await db.settingsView(pool, { project: P });
+  assert.deepEqual(v.settings, { ...db.DEFAULT_SETTINGS }, 'an unconfigured project reads the watch as off');
+  assert.equal(v.nextRunDue, null);
+});
+
+// ---- the migration's own rules -------------------------------------------
+
+test('the migration is additive, namespaced, idempotent, transactional and ASCII', () => {
+  assert.match(MIGRATION, /^\s*BEGIN;/m);
+  assert.match(MIGRATION, /^\s*COMMIT;/m);
+  const code = MIGRATION.replace(/--[^\n]*/g, ''); // the prose may say "never a DELETE"
+  assert.doesNotMatch(code, /\bDROP\b|\bTRUNCATE\b|\bDELETE\b/i);
+  assert.ok(/^[\x00-\x7F]*$/.test(MIGRATION), 'ASCII only');
+  const tables = [...MIGRATION.matchAll(/CREATE TABLE (IF NOT EXISTS )?(\w+)/g)];
+  assert.equal(tables.length, 10);
+  for (const t of tables) {
+    assert.ok(t[1], `${t[2]} is IF NOT EXISTS`);
+    assert.match(t[2], /^market_watch_/);
+  }
+  for (const i of MIGRATION.matchAll(/CREATE (UNIQUE )?INDEX (IF NOT EXISTS )?(\w+)/g)) assert.ok(i[2], `${i[3]} is IF NOT EXISTS`);
+});
+
+test('every seed ON CONFLICT target is a unique key the migration declares', () => {
+  const src = readFileSync(new URL('../modules/market-watch/seed.js', import.meta.url), 'utf8');
+  const want = {
+    '(project, version)': /UNIQUE \(project, version\)/,
+    '(project) WHERE trigger = \'seed\'': /market_watch_runs_one_seed\s+ON market_watch_runs \(project\) WHERE trigger = 'seed'/,
+    '(project, kind, url, name)': /UNIQUE \(project, kind, url, name\)/,
+    '(item_id, run_id, dimension)': /UNIQUE \(item_id, run_id, dimension\)/,
+    '(item_id, run_id, md5(takeaway))': /market_watch_log_entries_once\s+ON market_watch_log_entries \(item_id, run_id, md5\(takeaway\)\)/,
+  };
+  const targets = [...src.matchAll(/ON CONFLICT (.+?) DO NOTHING/g)].map((m) => m[1]);
+  assert.equal(targets.length, Object.keys(want).length);
+  for (const t of targets) {
+    assert.ok(want[t], `unexpected conflict target ${t}`);
+    assert.match(MIGRATION, want[t], t);
+  }
+});

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