@bongos/core 1.24.6 → 1.24.8

package/modules/market-watch/rules-logic.js

@@ -0,0 +1,264 @@
+'use strict';
+
+// modules/market-watch/rules-logic.js — the rules page's arithmetic, with no database
+// (task 1004941, goal 1000137). The page is the pipeline map of
+// docs/design/mocks/market-watch/rules.html (option C): searches, then sources, then
+// names, then scoring, then the brief. Everything the page shows about a rules version,
+// and every change a member may propose to one, is decided here, so the route, the
+// approval and the tests all read one definition.
+//
+// A CHANGE IS A SMALL, CLOSED DELTA, never a whole new rules object. A member proposes
+// one step's change ("add this search", "count this score double", "rewrite the brief"),
+// with a reason. Approving it applies the delta to the version IN USE at that moment, so
+// a proposal made against v6 and approved after v7 still lands on v7 and loses nothing
+// v7 added. A delta that no longer applies (the search it removes is already gone) is
+// refused at approval with `no_longer_applies`, never applied half-way.
+//
+//   searches  { op: 'add' | 'remove', text }
+//   sources   { op: 'add' | 'remove', text }
+//   scoring   { op: 'weight', kind, key, weight }       weight 0..3 (0 = not counted)
+//             { op: 'define', kind, key, definition }   what a 0 and a 10 mean
+//   brief     { op: 'set', text }                        the AI instructions
+//   names     { op: 'add', name, url, kind, why }        → an add_item proposal
+//             { op: 'remove', item_id }                  → a remove_item proposal
+//
+// The names step changes WHO is watched, not the rules, so its two ops become item
+// proposals (the kinds the item page and the weekly ask also file) rather than rules
+// versions. Every other step's change becomes, once approved, a new rules version.
+
+const STEPS = Object.freeze([
+  Object.freeze({ key: 'searches', label: 'searches', title: 'what we search for' }),
+  Object.freeze({ key: 'sources', label: 'sources', title: 'what we read' }),
+  Object.freeze({ key: 'names', label: 'names', title: 'who we watch' }),
+  Object.freeze({ key: 'scoring', label: 'scoring', title: 'how we score' }),
+  Object.freeze({ key: 'brief', label: 'brief', title: 'what we ask the AI to write' }),
+]);
+const STEP_KEYS = Object.freeze(STEPS.map((s) => s.key));
+const RULE_STEPS = Object.freeze(['searches', 'sources', 'scoring', 'brief']);
+const ITEM_KINDS = Object.freeze(['competitor', 'partner', 'topic']);
+
+const LIMITS = Object.freeze({ text: 300, brief: 4000, name: 200, url: 500, why: 500, reason: 500, maxWeight: 3, maxList: 40 });
+
+const clean = (s) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim();
+const same = (a, b) => clean(a).toLowerCase() === clean(b).toLowerCase();
+const isHttp = (u) => /^https?:\/\/[^\s<>"']+$/i.test(u);
+const fail = (reason, field) => ({ ok: false, reason, ...(field ? { field } : {}) });
+
+// The rules fields a version carries, normalised (a row from the database, or a
+// version built here).
+function fieldsOf(v) {
+  const r = v || {};
+  return {
+    search_queries: Array.isArray(r.search_queries) ? r.search_queries.map(String) : [],
+    sources: Array.isArray(r.sources) ? r.sources.map(String) : [],
+    rubric: r.rubric && typeof r.rubric === 'object' ? JSON.parse(JSON.stringify(r.rubric)) : {},
+    instructions: typeof r.instructions === 'string' ? r.instructions : '',
+  };
+}
+
+// checkReason(text) → { ok, reason } — every proposal says why, in one line.
+function checkReason(text) {
+  const r = clean(text);
+  if (!r) return fail('reason_required', 'reason');
+  if (r.length > LIMITS.reason) return fail('reason_too_long', 'reason');
+  return { ok: true, reason: r };
+}
+
+// checkChange(step, change, rules) → { ok: true, step, change, kind } | { ok: false, reason, field }
+// `kind` is the proposal kind it files as: rule_change, add_item or remove_item. The
+// change is rebuilt from known fields only, so nothing a caller adds rides along.
+function checkChange(step, change, rules) {
+  if (!STEP_KEYS.includes(step)) return fail('unknown_step', 'step');
+  const c = change && typeof change === 'object' && !Array.isArray(change) ? change : null;
+  if (!c) return fail('bad_change', 'change');
+  const f = fieldsOf(rules);
+  if (step === 'searches' || step === 'sources') {
+    const list = step === 'searches' ? f.search_queries : f.sources;
+    const text = clean(c.text);
+    if (!text) return fail('text_required', 'change.text');
+    if (text.length > LIMITS.text) return fail('text_too_long', 'change.text');
+    if (c.op === 'add') {
+      if (list.some((x) => same(x, text))) return fail('already_there', 'change.text');
+      if (list.length >= LIMITS.maxList) return fail('list_full', 'change.text');
+    } else if (c.op === 'remove') {
+      if (!list.some((x) => same(x, text))) return fail('not_there', 'change.text');
+    } else return fail('bad_op', 'change.op');
+    return { ok: true, step, kind: 'rule_change', change: { op: c.op, text } };
+  }
+  if (step === 'scoring') {
+    const dims = Array.isArray(f.rubric[c.kind]) ? f.rubric[c.kind] : null;
+    if (!dims) return fail('unknown_kind', 'change.kind');
+    const dim = dims.find((d) => d && d.key === c.key);
+    if (!dim) return fail('unknown_dimension', 'change.key');
+    if (c.op === 'weight') {
+      const w = Number(c.weight);
+      if (!Number.isInteger(w) || w < 0 || w > LIMITS.maxWeight) return fail('bad_weight', 'change.weight');
+      if (w === weightOf(dim)) return fail('no_change', 'change.weight');
+      return { ok: true, step, kind: 'rule_change', change: { op: 'weight', kind: c.kind, key: c.key, weight: w } };
+    }
+    if (c.op === 'define') {
+      const d = clean(c.definition);
+      if (!d) return fail('text_required', 'change.definition');
+      if (d.length > LIMITS.text) return fail('text_too_long', 'change.definition');
+      if (same(d, dim.definition)) return fail('no_change', 'change.definition');
+      return { ok: true, step, kind: 'rule_change', change: { op: 'define', kind: c.kind, key: c.key, definition: d } };
+    }
+    return fail('bad_op', 'change.op');
+  }
+  if (step === 'brief') {
+    if (c.op !== 'set') return fail('bad_op', 'change.op');
+    const text = String(c.text == null ? '' : c.text).trim();
+    if (!text) return fail('text_required', 'change.text');
+    if (text.length > LIMITS.brief) return fail('text_too_long', 'change.text');
+    if (same(text, f.instructions)) return fail('no_change', 'change.text');
+    return { ok: true, step, kind: 'rule_change', change: { op: 'set', text } };
+  }
+  // names
+  if (c.op === 'add') {
+    const name = clean(c.name);
+    if (!name) return fail('name_required', 'change.name');
+    if (name.length > LIMITS.name) return fail('name_too_long', 'change.name');
+    const kind = ITEM_KINDS.includes(c.kind) ? c.kind : null;
+    if (!kind) return fail('unknown_kind', 'change.kind');
+    const url = clean(c.url);
+    if (url && (url.length > LIMITS.url || !isHttp(url))) return fail('bad_url', 'change.url');
+    if (!url && kind !== 'topic') return fail('url_required', 'change.url');
+    const why = clean(c.why).slice(0, LIMITS.why);
+    return { ok: true, step, kind: 'add_item', change: { op: 'add', name, url, kind, why } };
+  }
+  if (c.op === 'remove') {
+    const id = Number(c.item_id);
+    if (!Number.isSafeInteger(id) || id <= 0) return fail('bad_item', 'change.item_id');
+    return { ok: true, step, kind: 'remove_item', change: { op: 'remove', item_id: id } };
+  }
+  return fail('bad_op', 'change.op');
+}
+
+const weightOf = (d) => (d && Number.isInteger(d.weight) ? d.weight : 1);
+
+// applyChange(rules, step, change) → { ok: true, fields } | { ok: false, reason }.
+// Re-checks the change against THESE rules first (they may be newer than the ones it was
+// proposed against), so an approval never writes a version the change does not fit.
+function applyChange(rules, step, change) {
+  if (!RULE_STEPS.includes(step)) return fail('not_a_rule_change');
+  const check = checkChange(step, change, rules);
+  if (!check.ok) return { ok: false, reason: 'no_longer_applies', why: check.reason };
+  const f = fieldsOf(rules);
+  const c = check.change;
+  if (step === 'searches' || step === 'sources') {
+    const field = step === 'searches' ? 'search_queries' : 'sources';
+    f[field] = c.op === 'add' ? [...f[field], c.text] : f[field].filter((x) => !same(x, c.text));
+  } else if (step === 'scoring') {
+    f.rubric[c.kind] = f.rubric[c.kind].map((d) => (d.key !== c.key ? d
+      : (c.op === 'weight' ? { ...d, weight: c.weight } : { ...d, definition: c.definition })));
+  } else {
+    f.instructions = c.text;
+  }
+  return { ok: true, fields: f };
+}
+
+const short = (s, n = 48) => { const t = clean(s); return t.length > n ? `${t.slice(0, n - 1)}…` : t; };
+function dimLabel(rules, kind, key) {
+  const d = (fieldsOf(rules).rubric[kind] || []).find((x) => x.key === key);
+  return d ? (d.label || d.key) : key;
+}
+
+// summarize(step, change, rules) → the slider's one line ("+ GitHub releases as a source").
+function summarize(step, change, rules) {
+  const c = change || {};
+  switch (step) {
+    case 'searches': return c.op === 'add' ? `+ "${short(c.text)}" as a search` : `dropped the "${short(c.text)}" search`;
+    case 'sources': return c.op === 'add' ? `+ ${short(c.text)} as a source` : `stopped reading ${short(c.text)}`;
+    case 'scoring': return c.op === 'weight'
+      ? `"${dimLabel(rules, c.kind, c.key)}" counts ×${c.weight}`
+      : `"${dimLabel(rules, c.kind, c.key)}" redefined`;
+    case 'brief': return 'brief rewritten';
+    case 'names': return c.op === 'add' ? `+ ${short(c.name)} watched` : 'stop watching a name';
+    default: return 'rules changed';
+  }
+}
+
+// changedSteps(prev, next) → the steps whose rules differ between two versions: the
+// slider marks those nodes when it lands on `next`.
+function changedSteps(prev, next) {
+  if (!prev) return [];
+  const a = fieldsOf(prev);
+  const b = fieldsOf(next);
+  const out = [];
+  if (JSON.stringify(a.search_queries) !== JSON.stringify(b.search_queries)) out.push('searches');
+  if (JSON.stringify(a.sources) !== JSON.stringify(b.sources)) out.push('sources');
+  if (JSON.stringify(a.rubric) !== JSON.stringify(b.rubric)) out.push('scoring');
+  if (a.instructions !== b.instructions) out.push('brief');
+  return out;
+}
+
+// proposedNext(active, openRuleProposals) → the slider's "v8?": the version in use with
+// every open rule change applied in the order they were made. A change that would not
+// apply on top of the others is left out and counted, so the preview never lies about
+// what approving all of them would give.
+function proposedNext(active, open) {
+  if (!active) return null;
+  let fields = fieldsOf(active);
+  let applied = 0;
+  let skipped = 0;
+  const list = [...(open || [])].sort((x, y) => Number(x.id) - Number(y.id));
+  for (const p of list) {
+    const payload = p.payload || {};
+    const out = applyChange(fields, payload.step, payload.change);
+    if (out.ok) { fields = out.fields; applied += 1; } else skipped += 1;
+  }
+  if (!applied) return null;
+  return { version: Number(active.version) + 1, ...fields, applied, skipped, changed: changedSteps(active, fields) };
+}
+
+// ---- the cost of one run, by step -------------------------------------------------
+//
+// The weekly run makes ONE Messages API call per tracked item (research.js): the
+// searches, the page reads, the scoring and the written lines all happen in that call,
+// and the API bills them as searches plus tokens in and out. So no stored number says
+// what each step cost. The SPLIT is always an estimate, from ADR 0394's per-item figure
+// (2 searches; about 25k tokens of search and page content read; about 2k tokens out,
+// shared here evenly between the scores with their reasons and the written takeaways).
+// The TOTAL is real when a run has finished with a cost (market_watch_run_items, the
+// accounting the cap sums, and its cost_log mirror), and the page says which.
+const EXPECTED_PER_ITEM = Object.freeze({ searches: 2, inputTokens: 25000, outputTokens: 2000 });
+
+function estimatePerItem(pricing, model) {
+  const searches = pricing.priceWebSearches(EXPECTED_PER_ITEM.searches);
+  const reading = pricing.priceUsage(model, { input_tokens: EXPECTED_PER_ITEM.inputTokens }).usd;
+  const output = pricing.priceUsage(model, { output_tokens: EXPECTED_PER_ITEM.outputTokens }).usd;
+  return { read: searches + reading, score: output / 2, brief: output / 2 };
+}
+
+const cents = (n) => Math.round(n * 100) / 100;
+
+// costByStep({ items, lastRun, pricing, model }) →
+//   { basis: 'run' | 'estimate', total, run: {n, items, cost_log_usd} | null,
+//     rows: [{ step, label, usd }], split: 'estimate' }
+// lastRun: { n, items, cost_usd, cost_log_usd } of the newest run that ran with a cost.
+function costByStep({ items, lastRun = null, pricing, model }) {
+  const per = estimatePerItem(pricing, model);
+  const perTotal = per.read + per.score + per.brief;
+  const count = Math.max(0, Number(items) || 0);
+  const real = lastRun && Number(lastRun.cost_usd) > 0 ? lastRun : null;
+  const scoredNames = real ? Number(real.items) || count : count;
+  const total = real ? Number(real.cost_usd) : perTotal * count;
+  const share = (part) => (perTotal > 0 ? total * (part / perTotal) : 0);
+  return {
+    basis: real ? 'run' : 'estimate',
+    split: 'estimate',
+    total: cents(total),
+    run: real ? { n: real.n, items: scoredNames, cost_log_usd: real.cost_log_usd == null ? null : cents(Number(real.cost_log_usd)) } : null,
+    rows: [
+      { step: 'read', label: 'searches + reading pages', usd: cents(share(per.read)) },
+      { step: 'score', label: `scoring ${scoredNames} names`, usd: cents(share(per.score)) },
+      { step: 'brief', label: 'writing the brief', usd: cents(share(per.brief)) },
+    ],
+  };
+}
+
+module.exports = {
+  STEPS, STEP_KEYS, RULE_STEPS, ITEM_KINDS,
+  checkReason, checkChange, applyChange, summarize, changedSteps, proposedNext,
+  costByStep, fieldsOf, weightOf,
+};

package/modules/market-watch/rules-view.js

@@ -0,0 +1,165 @@
+'use strict';
+
+// modules/market-watch/rules-view.js — everything the rules page shows, in one read
+// (task 1004941, goal 1000137). The page is the pipeline map
+// (docs/design/mocks/market-watch/rules.html, option C): five steps with their counts,
+// each step's rules in plain words, the open proposals on each step, the version slider
+// (v1 to the version in use, plus the proposed next one) and the cost of one run by step.
+//
+// The view is built by the PURE `buildView` from rows the route reads, so the test can
+// hand it rows and read the page model without a database. Who may decide is passed in
+// (the route asks the owner check and the government port), never worked out here.
+
+const logic = require('./rules-logic');
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+const LAST_RUN_COST_SQL = `-- mw:last-run-cost
+  SELECT r.id, r.created_at,
+         COALESCE(sum(ri.cost_usd), 0) AS cost_usd,
+         (count(ri.item_id) FILTER (WHERE ri.status = 'done'))::int AS items,
+         (SELECT sum(c.amount_usd) FROM cost_log c WHERE c.source = 'market-watch:' || r.id) AS cost_log_usd
+    FROM market_watch_runs r
+    JOIN market_watch_run_items ri ON ri.run_id = r.id
+   WHERE r.project = $1 AND r.status IN ('done', 'partial') AND r.trigger <> 'seed'
+   GROUP BY r.id
+  HAVING COALESCE(sum(ri.cost_usd), 0) > 0
+   ORDER BY r.created_at DESC, r.id DESC
+   LIMIT 1`;
+
+const NAMES_SQL = `-- mw:builder-names
+  SELECT id, github_login, display_name FROM builders WHERE id = ANY($1::bigint[])`;
+
+// One person, as the page shows them: a login, never an email or an id alone.
+const who = (names, id) => {
+  if (id == null) return null;
+  const b = names.get(String(id));
+  return b ? (b.display_name || b.github_login || `builder ${id}`) : `builder ${id}`;
+};
+
+// The step a proposal is shown on. A rule change names its own; every item proposal
+// (added or removed here, or the item page's and weekly ask's kinds) is about who we
+// watch, so the owner decides all of them on the names step.
+function stepOf(p) {
+  if (p.kind === 'rule_change') return (p.payload && p.payload.step) || null;
+  return 'names';
+}
+
+// The words a step's panel shows: the rules themselves, in plain words.
+function stepRules(step, fields, items) {
+  switch (step) {
+    case 'searches': return { list: fields.search_queries };
+    case 'sources': return { list: fields.sources };
+    case 'names': return {
+      top: items.filter((i) => i.status === 'active')
+        .slice().sort((a, b) => (b.overall ?? -1) - (a.overall ?? -1) || a.name.localeCompare(b.name))
+        .slice(0, 6)
+        .map((i) => ({ id: i.id, name: i.name, kind: i.kind, overall: i.overall })),
+    };
+    case 'scoring': return {
+      kinds: Object.keys(fields.rubric).sort().map((kind) => ({
+        kind,
+        dims: (fields.rubric[kind] || []).map((d) => ({ key: d.key, label: d.label || d.key, definition: d.definition || '', weight: logic.weightOf(d) })),
+      })),
+    };
+    case 'brief': return { text: fields.instructions };
+    default: return {};
+  }
+}
+
+// buildView({ versions, items, proposals, lastRun, names, decide, now, pricing, model })
+function buildView({ versions = [], items = [], proposals = [], lastRun = null, names = new Map(), decide = {}, now = new Date(), pricing, model }) {
+  const ordered = versions.filter((v) => v.status === 'active' || v.status === 'superseded')
+    .slice().sort((a, b) => a.version - b.version);
+  const active = ordered.find((v) => v.status === 'active') || null;
+  const fields = logic.fieldsOf(active);
+  const live = items.filter((i) => i.status === 'active');
+  const weekAgo = new Date(new Date(now).getTime() - 7 * DAY_MS);
+  const openRule = proposals.filter((p) => p.status === 'open' && p.kind === 'rule_change');
+  const next = logic.proposedNext(active, openRule);
+
+  const open = proposals.filter((p) => p.status === 'open').map((p) => ({
+    id: p.id,
+    kind: p.kind,
+    origin: p.origin,
+    step: stepOf(p),
+    summary: (p.payload && p.payload.summary) || logic.summarize(stepOf(p), p.payload && p.payload.change, active) || p.kind,
+    reason: p.reason || '',
+    by: who(names, p.proposed_by),
+    created_at: p.created_at,
+    change: p.payload && p.payload.change ? p.payload.change : null,
+    at_vote: !!(p.payload && p.payload.matter_id),
+    name: p.kind === 'add_item' && p.payload ? (p.payload.name || (p.payload.change && p.payload.change.name) || null) : null,
+  }));
+
+  const countBy = (step) => open.filter((p) => p.step === step).length;
+  const dims = Object.values(fields.rubric).reduce((n, d) => Math.max(n, Array.isArray(d) ? d.length : 0), 0);
+  const briefLines = fields.instructions ? fields.instructions.split(/(?<=[.!?])\s+/).filter(Boolean).length : 0;
+  const steps = logic.STEPS.map((s) => {
+    const base = { key: s.key, label: s.label, title: s.title, open: countBy(s.key), rules: stepRules(s.key, fields, items) };
+    if (s.key === 'searches') return { ...base, value: fields.search_queries.length, sub: 'queries a run' };
+    if (s.key === 'sources') return { ...base, value: fields.sources.length, sub: 'kinds of page' };
+    if (s.key === 'names') {
+      // new = added this week by a proposal or a member, never the seeded research
+      const fresh = live.filter((i) => i.added_via !== 'seed' && i.created_at && new Date(i.created_at) >= weekAgo).length;
+      return { ...base, value: live.length, sub: fresh ? `${fresh} new this week` : 'being watched' };
+    }
+    if (s.key === 'scoring') return { ...base, value: dims, sub: 'things, 0–10' };
+    return { ...base, value: briefLines, sub: briefLines === 1 ? 'line of instructions' : 'lines of instructions' };
+  });
+
+  const history = ordered.map((v, i) => ({
+    version: v.version,
+    status: v.status,
+    summary: v.summary || '',
+    reason: v.reason || '',
+    by: who(names, v.author_id),
+    approved_by: who(names, v.approved_by),
+    approved_at: v.approved_at || null,
+    changed: logic.changedSteps(i ? ordered[i - 1] : null, v),
+    rules: logic.fieldsOf(v),
+  }));
+
+  return {
+    steps,
+    active: active ? { id: active.id, version: active.version } : null,
+    history,
+    next: next ? {
+      version: next.version,
+      applied: next.applied,
+      skipped: next.skipped,
+      changed: next.changed,
+      rules: { search_queries: next.search_queries, sources: next.sources, rubric: next.rubric, instructions: next.instructions },
+    } : null,
+    proposals: open,
+    cost: logic.costByStep({ items: live.length, lastRun, pricing, model }),
+    decide,
+  };
+}
+
+// readView(pool, { project, now, decide, pricing, model }) — the rows, then buildView.
+async function readView(pool, { project, now = new Date(), decide = {}, pricing, model, db = require('./db') }) {
+  const [rules, items, proposals, { rows: [last] }] = await Promise.all([
+    db.rules(pool, { project }),
+    db.listItems(pool, { project }),
+    db.proposals(pool, { project, status: 'open', limit: 200 }),
+    pool.query(LAST_RUN_COST_SQL, [project]),
+  ]);
+  let lastRun = null;
+  if (last) {
+    const runs = await db.numberedRuns(pool, { project });
+    const n = (runs.find((r) => String(r.id) === String(last.id)) || {}).n || null;
+    lastRun = { n, items: last.items, cost_usd: Number(last.cost_usd), cost_log_usd: last.cost_log_usd == null ? null : Number(last.cost_log_usd) };
+  }
+  const ids = new Set();
+  for (const v of rules.versions) { if (v.author_id) ids.add(String(v.author_id)); if (v.approved_by) ids.add(String(v.approved_by)); }
+  for (const p of proposals) if (p.proposed_by) ids.add(String(p.proposed_by));
+  const names = new Map();
+  if (ids.size) {
+    const { rows } = await pool.query(NAMES_SQL, [[...ids]]);
+    for (const b of rows) names.set(String(b.id), b);
+  }
+  return buildView({ versions: rules.versions, items, proposals, lastRun, names, decide, now, pricing, model });
+}
+
+module.exports = { buildView, readView };

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.24.6",
+  "version": "1.24.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.24.6",
+      "version": "1.24.8",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.24.6",
+  "version": "1.24.8",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -10871,5 +10871,17 @@
       "id": "1004995",
       "text": "On the account page, people can now link GitHub and Google to one account, both ways, so either one opens the same account with the same credits, ranks and history. They can remove one too, but never their last way in. Two exi"
     }
+  ],
+  "1.24.7": [
+    {
+      "id": "1005003",
+      "text": "The automatic tweak limit is now 200 rounds a month, and a project owner can change it, for the whole project and separately for each builder rank, on the project settings page."
+    }
+  ],
+  "1.24.8": [
+    {
+      "id": "1004941",
+      "text": "Every member can now read the Market Watch rules step by step, propose a change with a reason, and the owner (or the government, by vote) approves it into a new rules version that the next weekly run uses."
+    }
   ]
 }

package/scripts/bongos/government-walk.js

@@ -84,6 +84,7 @@ const REQUESTS = Object.freeze({
   'PATCH /project-settings/tweak-autopickup': ['PATCH', '/project-settings/tweak-autopickup', { mode: 'sometimes' }],
   'PATCH /project-settings/spend-cap': ['PATCH', '/project-settings/spend-cap', { usd: 'lots' }],
   'PATCH /work-categories/:id': ['PATCH', `/work-categories/${BAD}`, {}],
+  'POST /market-watch/proposals/:id/decide': ['POST', `/market-watch/proposals/${BAD}/decide`, { decision: 'approve' }],
   'POST /security/reports/:id/confirm': ['POST', `/security/reports/${BAD}/confirm`, {}],
   'POST /security/reports/:id/dispute': ['POST', `/security/reports/${BAD}/dispute`, {}],
   'POST /security/reports/:id/fix': ['POST', `/security/reports/${BAD}/fix`, {}],
@@ -123,6 +124,7 @@ const MATTER_PLAN = Object.freeze([
   ['release', 'Approve override request 5', { type: 'approve_override', request_id: 5 }, 'request 5 approved'],
   ['review', 'Sign off criterion 9', { type: 'satisfy_criterion', criterion_id: 9 }, 'criterion 9 satisfied'],
   ['treasury', 'Dee gets $50 a month', { type: 'set_budget', builder_id: 45, monthly_usd: 50 }, 'Dee\'s limit is $50'],
+  ['rules', 'Market Watch: + bounty boards as a search', { type: 'market_watch_proposal', proposal_id: 12 }, 'proposal 12 approved'],
 ]);
 
 // Every router the walk drives, mounted as the server mounts them.
@@ -145,6 +147,8 @@ const ROUTERS = Object.freeze([
   // the new machinery's other doors: a blocker and its ask, a builder's settings
   'modules/ideas/routes/blockers.js',
   'modules/builder-settings/routes/settings.js',
+  // task 1004941: the owner's decide route (a Rules act) and the Rules matter act
+  'modules/market-watch/routes/rules.js',
 ]);
 
 // ── the in-memory government store ──────────────────────────────────────────
@@ -633,7 +637,17 @@ async function runWalk() {
   projectSettings.setSetting = async (k, v) => { settings.set(k, String(v)); return { key: k, value: String(v) }; };
 
   // What passed matters write into other modules, recorded.
-  const effects = { fence: null, allowedGoals: [], overrides: [], criteria: new Map([['9', false]]), budgets: new Map() };
+  const effects = { fence: null, allowedGoals: [], overrides: [], criteria: new Map([['9', false]]), budgets: new Map(), mwApproved: [] };
+  // task 1004941: a passed Rules matter approves a Market Watch proposal through the
+  // module's own decideProposal; here it is recorded instead of written.
+  const mwActs = req('modules/market-watch/matter-acts.js');
+  const mwProposals = req('modules/market-watch/proposals.js');
+  mwActs.runtime.project = () => 'https://walk.example';
+  mwActs.runtime.withTx = async (fn) => fn(null);
+  mwProposals.decideProposal = async ({ id, decision }) => {
+    if (decision === 'approve') effects.mwApproved.push(String(id));
+    return { ok: true, status: 'applied', applied: true };
+  };
   autoDb.setFenceEnabled = async ({ enabled }) => { effects.fence = enabled; return { enabled }; };
   autoDb.allowGoal = async ({ goalId }) => { effects.allowedGoals.push(String(goalId)); return { goal_id: goalId }; };
   lifeDb.decideOverrideRequest = async ({ requestId, decision }) => { effects.overrides.push([String(requestId), decision]); return {}; };
@@ -943,6 +957,7 @@ async function runWalk() {
   section('M Matters');
   const SITTINGS = {
     people: 'consent', automation: 'majority', release: 'unanimous', review: 'signoff', treasury: 'first',
+    rules: 'majority',
   };
   await check('Each acting building is put to the council by one passed amendment', Object.entries(SITTINGS).map(([a, r]) => `${a} ${r}`).join(', '), async () => {
     const out = await setRules(Object.entries(SITTINGS).map(([area, rule]) => ({ area, decided_by: 'rank:council', rule })));
@@ -971,12 +986,13 @@ async function runWalk() {
     'release.approve_override': () => effects.overrides.some(([id, d]) => id === '5' && d === 'approve'),
     'review.satisfy_criterion': () => effects.criteria.get('9') === true,
     'treasury.set_budget': () => effects.budgets.get('45') === 50,
+    'rules.market_watch_proposal': () => effects.mwApproved.includes('12'),
   };
   const MATTERS = MATTER_PLAN.map(([area, title, action, effect]) => [area, title, action, effect, HAPPENED[`${area}.${action.type}`]]);
   // How each building's sitting closes as Ben then Cy say yes, under its rule: the
   // two-member consent, majority and unanimous sittings need both; first yes and
   // sign-off (by someone who did not propose it) close on the first.
-  const CLOSES = { people: 'open, passed', automation: 'open, passed', release: 'open, passed', review: 'passed', treasury: 'passed' };
+  const CLOSES = { people: 'open, passed', automation: 'open, passed', release: 'open, passed', review: 'passed', treasury: 'passed', rules: 'open, passed' };
   await check('Someone the building\'s row does not seat cannot vote on its matter', '403 not_board_member', async () => {
     const r = await call(FOUNDER, 'POST', '/government/board/matters', { area: 'automation', title: 'Who may vote here?' });
     const itemId = r.json && r.json.item && r.json.item.id;

package/scripts/bongos/run-unit-tests.js

@@ -93,6 +93,9 @@ const INTEGRATION = new Set([
   // idempotent and a resumed run unable to record an item twice. DB-free sibling:
   // market_watch_data.
   'market_watch_data_db',
+  // task 1004941: a rules proposal round-trips to a new version the weekly run's loader
+  // reads, on real SQL (the one-active index, the CHECKs). DB-free sibling: market_watch_rules.
+  'market_watch_rules_db',
   // task 1004940: the weekly ask's SQL store — once per week by constraint, one pooled
   // proposal per similar answer, the project guard on an answer. DB-free sibling:
   // market_watch_ask.

package/src/bongos/module-scope-map.js

@@ -198,6 +198,8 @@ const MODULE_GLOBS = {
     'modules/market-watch/', 'tests/market_watch_module.mjs',
     'tests/market_watch_data.mjs', 'tests/market_watch_data_db.mjs',
     'tests/market_watch_run.mjs',
+    // task 1004941: the rules page (proposals, decisions, the run's prompt fence)
+    'tests/market_watch_rules.mjs', 'tests/market_watch_rules_db.mjs',
     'tests/market_watch_ask.mjs', 'tests/market_watch_ask_db.mjs',
   ],
   // --- builder prefs (wandering/skill/sound/render) + builder-needs ---