@bongos/core 1.24.11 → 1.24.13

package/modules/lifecycle/autopickup.js

@@ -11,6 +11,7 @@
 //   - the claim is marked but the task is not a page-tweak round  (AUTO_PICKUP_NOT_A_TWEAK)
 //   - the project has tweak.autopickup off                         (AUTO_PICKUP_OFF)
 //   - this calendar month already holds `cap` marked claims        (AUTO_PICKUP_CAP_REACHED)
+//   - the claimer already used their rank's per-person allowance  (AUTO_PICKUP_CAP_REACHED, cap_from rank)
 //   - this round already has two marked claims                     (AUTO_PICKUP_ROUND_LIMIT)
 //
 // THE LOCK. The count and the claim insert must not interleave with another
@@ -56,26 +57,37 @@ async function countForRound(exec, taskId) {
   return Number(rows[0] && rows[0].n) || 0;
 }
 
-// effectiveCap(settings, rank) — { cap, from: 'rank' | 'project' } (task 1005003).
-// The claimer's rank's own cap when the project set one, else the project cap. The
-// cap is measured against the project's monthly count either way: a rank cap says
-// how far into the month a runner of that rank may still pick up, not a separate
-// allowance per builder, so the ledger count stays one project-wide number. Pure.
-function effectiveCap(settings, rank) {
-  const s = settings || {};
-  const caps = s.rank_caps || {};
-  if (rank && Object.prototype.hasOwnProperty.call(caps, rank) && Number.isInteger(caps[rank])) {
-    return { cap: caps[rank], from: 'rank' };
-  }
-  return { cap: s.cap, from: 'project' };
+// The same month, narrowed to ONE builder's marked claims (task 1005019): the
+// ledger count a per-person rank allowance is measured against.
+const BUILDER_MONTH_COUNT_SQL = `${MONTH_COUNT_SQL}
+     AND c.builder_id = $1`;
+
+async function countThisMonthFor(exec, builderId) {
+  const { rows } = await exec.query(BUILDER_MONTH_COUNT_SQL, [builderId]);
+  return Number(rows[0] && rows[0].n) || 0;
 }
 
-// autoPickupRefusal(client, task, settings, rank) — null when the marked claim may
-// proceed, else the refusal object claimTask throws. `settings` is the resolved
-// { mode, cap, rank_caps }, read BEFORE the transaction opens (the
+// rankAllowance(settings, rank) — the per-PERSON monthly allowance the project set
+// for this rank, or null when it set none (task 1005019, the owner's 2026-10-30
+// ruling on task 1005003). Each builder of the rank gets this many rounds of their
+// own; the project cap still bounds everyone's total. Pure.
+function rankAllowance(settings, rank) {
+  const caps = (settings && settings.rank_caps) || {};
+  if (rank && Object.prototype.hasOwnProperty.call(caps, rank) && Number.isInteger(caps[rank])) return caps[rank];
+  return null;
+}
+
+// autoPickupRefusal(client, task, settings, rank, builderId) — null when the marked
+// claim may proceed, else the refusal object claimTask throws. `settings` is the
+// resolved { mode, cap, rank_caps }, read BEFORE the transaction opens (the
 // claimPermissionsFor precedent: a settings read is not part of the claim's
-// consistency). `rank` is the claimer's rank, read inside it.
-async function autoPickupRefusal(client, task, settings, rank = null) {
+// consistency). `rank` and `builderId` are the claimer's, read inside it.
+//
+// Two limits, checked in this order, both under the lock:
+//   1. the PROJECT cap, on everyone's marked claims this month (cap_from 'project');
+//   2. the claimer's RANK allowance, on THEIR OWN marked claims this month
+//      (cap_from 'rank') — only when the project set one for their rank.
+async function autoPickupRefusal(client, task, settings, rank = null, builderId = null) {
   if (!task || task.source !== PAGE_TWEAK_SOURCE) {
     return { code: 'AUTO_PICKUP_NOT_A_TWEAK', message: 'Only a page tweak round can be claimed with the auto_pickup mark.' };
   }
@@ -92,12 +104,21 @@ async function autoPickupRefusal(client, task, settings, rank = null) {
     };
   }
   const used = await countThisMonth(client);
-  const { cap, from } = effectiveCap(s, rank);
-  if (used >= cap) {
-    const message = from === 'rank'
-      ? `This month's auto-pickups have reached ${cap}, the limit this project sets for a ${rank} builder's runner, so submitted pages wait for a person until next month.`
-      : `Auto-pickup has used this month's ${cap} rounds, so submitted pages wait for a person until next month.`;
-    return { code: 'AUTO_PICKUP_CAP_REACHED', used, cap, cap_from: from, message };
+  if (used >= s.cap) {
+    return {
+      code: 'AUTO_PICKUP_CAP_REACHED', used, cap: s.cap, cap_from: 'project',
+      message: `The project limit is reached: auto-pickup has used this month's ${s.cap} rounds for the whole project, so submitted pages wait for a person until next month.`,
+    };
+  }
+  const allowance = rankAllowance(s, rank);
+  if (allowance != null) {
+    const mine = await countThisMonthFor(client, builderId);
+    if (mine >= allowance) {
+      return {
+        code: 'AUTO_PICKUP_CAP_REACHED', used: mine, cap: allowance, cap_from: 'rank',
+        message: `Your own limit is reached: each ${rank} builder gets ${allowance} auto-pickup rounds a month, and you have used ${mine}, so submitted pages wait for a person until next month.`,
+      };
+    }
   }
   return null;
 }
@@ -106,6 +127,7 @@ module.exports = {
   LOCK_KEY,
   MAX_AUTO_APPLIES_PER_ROUND,
   countThisMonth,
-  effectiveCap,
+  countThisMonthFor,
+  rankAllowance,
   autoPickupRefusal,
 };

package/modules/lifecycle/db-claims.js

@@ -374,7 +374,7 @@ async function claimTask({ taskId, builderId, worktreeName, headSha, creatorSess
     // limit are counted under a project-wide advisory lock that this transaction
     // holds through the insert below, so two runners cannot both take the last slot.
     if (autoPickup) {
-      const refusal = await autoPickupRefusal(client, task, autoPickupSettings, builderRank);
+      const refusal = await autoPickupRefusal(client, task, autoPickupSettings, builderRank, builderId);
       if (refusal) throw refusal;
     }
 

package/modules/lifecycle/routes/project-settings.js

@@ -102,9 +102,10 @@ function shipModeRow(resolved) {
 
 // --- the monthly tweak-round cap (task 1005003) -----------------------------
 //
-// The project cap and one optional cap per builder rank, editable on the settings
-// page. The ranks come from the kernel's live ladder, never re-typed here or on the
-// page; a rank with no number follows the project cap.
+// The project cap and one optional per-PERSON limit per builder rank (task
+// 1005019), editable on the settings page. The ranks come from the kernel's live
+// ladder, never re-typed here or on the page; a rank with no number has no limit
+// of its own, only the project's.
 function tweakCapRow(resolved) {
   const r = resolved || {};
   const rankCaps = r.rank_caps || {};
@@ -118,8 +119,9 @@ function tweakCapRow(resolved) {
       max: api.projectSettings.MAX_AUTOPICKUP_CAP,
       ranks: api.LIVE_RANK_LADDER.map((rank) => ({ rank, cap: Object.prototype.hasOwnProperty.call(rankCaps, rank) ? rankCaps[rank] : null })),
     },
-    sentence: `Tweak auto-pickup may apply up to ${r.cap} submitted pages a month. A builder rank can have its own limit; `
-      + 'a rank left blank follows the project limit. When the limit is reached, pages wait for a person.',
+    sentence: `Tweak auto-pickup may apply up to ${r.cap} submitted pages a month for the whole project. A builder rank can `
+      + 'also have a limit per person: each builder of that rank gets that many rounds of their own, within the project total. '
+      + 'A rank left blank has only the project limit. When a limit is reached, pages wait for a person.',
     source: r.source ? r.source.cap : 'default',
     // Only a cap value this row draws; an unusable on/off switch is not this row's.
     invalid: (r.invalid || []).find((i) => /autopickup_(monthly_cap|rank_cap\.)/.test(String(i && i.where))) || null,
@@ -567,22 +569,28 @@ module.exports = function buildProjectSettingsRouter() {
   // rank: any signed-in builder. The runner reads it before it tries a round, and
   // the studio shows the count; it carries no reward internals or file paths.
   //
-  // cap is the project's; rank_caps the per-rank caps the project set (task
-  // 1005003). my_cap is the one that applies to the CALLER's rank, and
-  // remaining_this_month is measured against it, so a runner reads the number the
-  // claim gate will hold it to.
-  async function autopickupBody(rank = null) {
+  // cap is the project's total; rank_caps the per-PERSON allowance each rank gets
+  // (tasks 1005003, 1005019). my_rank_cap is the CALLER's own allowance (null when
+  // their rank has none) and used_by_me_this_month their own marked claims, and
+  // remaining_this_month is the smaller of what is left of the project total and
+  // of their own allowance — the number the claim gate will hold them to.
+  async function autopickupBody(builder = null) {
     const resolved = await api.projectSettings.resolveTweakAutopickup();
     const used = await autopickup.countThisMonth();
-    const mine = autopickup.effectiveCap(resolved, rank);
+    const allowance = autopickup.rankAllowance(resolved, builder && builder.rank);
+    const usedByMe = allowance != null && builder ? await autopickup.countThisMonthFor(api.pool, builder.id) : null;
+    const remaining = Math.max(0, Math.min(
+      resolved.cap - used,
+      allowance != null ? allowance - (usedByMe || 0) : Infinity,
+    ));
     return {
       mode: resolved.mode,
       cap: resolved.cap,
       rank_caps: resolved.rank_caps || {},
-      my_cap: mine.cap,
-      my_cap_from: mine.from,
+      my_rank_cap: allowance,
+      used_by_me_this_month: usedByMe,
       used_this_month: used,
-      remaining_this_month: Math.max(0, mine.cap - used),
+      remaining_this_month: remaining,
       per_round_limit: autopickup.MAX_AUTO_APPLIES_PER_ROUND,
       source: resolved.source,
       invalid: resolved.invalid,
@@ -593,7 +601,7 @@ module.exports = function buildProjectSettingsRouter() {
   router.get('/project-settings/tweak-autopickup', api.requireBuilder, async (req, res) => {
     try {
       res.set('Cache-Control', 'no-store');
-      res.json(await autopickupBody(req.builder && req.builder.rank));
+      res.json(await autopickupBody(req.builder || null));
     } catch (err) {
       log.error(`GET /project-settings/tweak-autopickup: ${err && err.message}`);
       res.fail('project_settings_read_failed', { status: 500, message: 'internal error' });
@@ -640,7 +648,7 @@ module.exports = function buildProjectSettingsRouter() {
       for (const [rank, n] of rankEdits) {
         await api.projectSettings.set(`${api.projectSettings.KEYS.TWEAK_AUTOPICKUP_RANK_CAP_PREFIX}${rank}`, n === null ? '' : n, req.builder.id);
       }
-      res.json({ ok: true, ...(await autopickupBody(req.builder && req.builder.rank)) });
+      res.json({ ok: true, ...(await autopickupBody(req.builder || null)) });
     } catch (err) {
       log.error(`PATCH /project-settings/tweak-autopickup: ${err && err.message}`);
       res.fail('project_settings_write_failed', { status: 500, message: 'internal error' });

package/modules/market-watch/db.js

@@ -130,14 +130,16 @@ const FOUND_IN_SQL = `
     JOIN market_watch_items i ON i.id = e.item_id
    WHERE i.project = $1 AND e.run_id IS NOT NULL AND ($2::bigint IS NULL OR e.item_id = $2)`;
 
+// `knownRuns` (here, in getItem, caseFile and scoreHistory): the numbered runs when the caller
+// already read them, so one page load reads market_watch_runs once (task 1004939).
 // listItems — the home desk: every tracked item with its latest overall score, last
 // finding, level and streak.
-async function listItems(pool, { project, kind = null, includeRemoved = false, id = null } = {}) {
+async function listItems(pool, { project, kind = null, includeRemoved = false, id = null, knownRuns = null } = {}) {
   need(project);
   const [{ rows: items }, { rows: found }, runs] = await Promise.all([
     pool.query(ITEMS_SQL, [project, kind, includeRemoved, id]),
     pool.query(FOUND_IN_SQL, [project, id]),
-    numberedRuns(pool, { project }),
+    knownRuns || numberedRuns(pool, { project }),
   ]);
   const byItem = new Map();
   for (const f of found) {
@@ -154,8 +156,8 @@ async function listItems(pool, { project, kind = null, includeRemoved = false, i
 }
 
 // getItem — one item, with removed ones included (its page still opens).
-async function getItem(pool, { project, id }) {
-  const rows = await listItems(pool, { project, includeRemoved: true, id });
+async function getItem(pool, { project, id, knownRuns = null }) {
+  const rows = await listItems(pool, { project, includeRemoved: true, id, knownRuns });
   return rows[0] || null;
 }
 
@@ -168,11 +170,11 @@ const CASE_FILE_SQL = `
    ORDER BY e.pinned DESC, e.found_on DESC, e.id DESC`;
 
 // caseFile — the item page's sortable table: found, run, type, takeaway, confidence, source.
-async function caseFile(pool, { project, itemId }) {
+async function caseFile(pool, { project, itemId, knownRuns = null }) {
   need(project);
   const [{ rows }, runs] = await Promise.all([
     pool.query(CASE_FILE_SQL, [project, itemId]),
-    numberedRuns(pool, { project }),
+    knownRuns || numberedRuns(pool, { project }),
   ]);
   const runN = new Map(runs.map((r) => [String(r.id), r.n]));
   return rows.map((e) => ({ ...e, id: Number(e.id), run: e.run_id == null ? null : runN.get(String(e.run_id)) ?? null }));
@@ -185,11 +187,11 @@ const SCORES_SQL = `
    WHERE i.project = $1 AND s.item_id = $2`;
 
 // scoreHistory — the item page's sparklines, one per dimension plus 'overall'.
-async function scoreHistory(pool, { project, itemId }) {
+async function scoreHistory(pool, { project, itemId, knownRuns = null }) {
   need(project);
   const [{ rows }, runs] = await Promise.all([
     pool.query(SCORES_SQL, [project, itemId]),
-    numberedRuns(pool, { project }),
+    knownRuns || numberedRuns(pool, { project }),
   ]);
   return sparklines(rows, runs);
 }
@@ -312,7 +314,8 @@ async function settingsView(pool, { project, now = new Date(), recent = 8 } = {}
 }
 
 const REMAINING_SQL = `
-  SELECT i.id, i.project, i.kind, i.name, i.url, i.description, i.why_tracked
+  SELECT i.id, i.project, i.kind, i.name, i.url, i.description, i.why_tracked,
+         COALESCE(i.facts->'watch_sources', '[]'::jsonb) AS watch_sources
     FROM market_watch_items i
     JOIN market_watch_runs r ON r.id = $2 AND r.project = i.project
    WHERE i.project = $1 AND i.status = 'active'
@@ -324,7 +327,9 @@ const REMAINING_SQL = `
 // no finished row in this run. An item already done is never returned, so it is never
 // researched, or charged, twice (ADR 0393 §2). An item that ERRORED is finished too: the
 // model ran and was paid for (task 1004937), so a resume does not buy it a second call.
-// Each row carries its project, so the run can refuse one that is not its own.
+// Each row carries its project, so the run can refuse one that is not its own, and the
+// links members added through an approved add_source proposal (facts.watch_sources,
+// task 1005017), so the run reads those too.
 async function remainingItems(pool, { project, runId }) {
   const { rows } = await pool.query(REMAINING_SQL, [need(project), runId]);
   return rows.map((r) => ({ ...r, id: Number(r.id) }));

package/modules/market-watch/module.json

@@ -1,7 +1,7 @@
 {
   "key": "market-watch",
   "title": "Market Watch (a weekly AI watch on a project's market)",
-  "description": "A weekly AI watch on a project's competitors, partners and topics, with a sourced log per tracked item and a weekly question to members (goal 1000137). Its data model (tables, read queries and the hub seed of the 2026-10-28 research), its weekly run (an hourly poller that researches each tracked item on the project's own Anthropic key, under the monthly cap), the weekly ask card in the hall's attention inbox (task 1004940), its rules page (the watch rules in plain words, members' proposed changes, and the owner's or the government's decision on each, task 1004941) and the owner's settings (on/off, monthly cap, cadence, the project key; task 1004938) are in. Off by default, and it cannot be turned on behind an open join door with no payer, because every run will spend the project's AI budget.",
+  "description": "A weekly AI watch on a project's competitors, partners and topics, with a sourced log per tracked item and a weekly question to members (goal 1000137). Its data model (tables, read queries and the hub seed of the 2026-10-28 research), its weekly run (an hourly poller that researches each tracked item on the project's own Anthropic key, under the monthly cap), the weekly ask card in the hall's attention inbox (task 1004940), its home and tracked-item pages (task 1004939), its rules page (the watch rules in plain words, members' proposed changes, and the owner's or the government's decision on each, task 1004941) and the owner's settings (on/off, monthly cap, cadence, the project key; task 1004938) are in. Off by default, and it cannot be turned on behind an open join door with no payer, because every run will spend the project's AI budget.",
   "version": "0.4.0",
   "coreVersion": "^1.22.0",
   "category": {
@@ -15,6 +15,7 @@
     "migrations": true,
     "routes": [
       "ask",
+      "pages",
       "rules",
       "settings"
     ],

package/modules/market-watch/pages.js

@@ -0,0 +1,323 @@
+'use strict';
+
+// modules/market-watch/pages.js — what the Market Watch home (the watchtower desk) and
+// the tracked-item page (the dossier) read and write (task 1004939, goal 1000137). The
+// designs of record are docs/design/mocks/market-watch/home.html (option D) and item.html
+// (option B).
+//
+// READS go through db.js (levels, streaks, run numbers, sparklines, spend and the next
+// due date are derived there) plus the two queries below that only these pages need: the
+// latest score per item and dimension (the landscape scope's dots) and the entries found
+// in the last seven days (this week's reports). Every query filters on the project key.
+//
+// SHAPES are pure (shapeHome, shapeItem): the routes call them on what the reads return,
+// and tests/market_watch_pages.mjs calls them on the committed seed, so the page's
+// numbers are checked without a database.
+//
+// THE ONE WRITE is a proposal (market_watch_proposals, origin 'member'). Every button on
+// the item page that would change what is watched files one: re-score, move between
+// partner and competitor, add a source, correct an entry, and stop tracking (a
+// remove_item). The home's "send a new scout" files an add_item. Approving them is the
+// rules page's (task 1004941); nothing here changes an item, a score or an entry.
+
+const db = require('./db');
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const WEEK_DAYS = 7;
+const KINDS = Object.freeze(['competitor', 'partner', 'topic']);
+const REPORT_LIMIT = 8;
+const STREAK_SLOTS = 9;
+const REASON_MAX = 280;
+const NAME_MAX = 120;
+const URL_MAX = 500;
+const DIM_RE = /^[a-z][a-z0-9_]{0,59}$/;
+// The four the item page's "Propose a change" offers, then the two the other buttons file.
+const ITEM_KINDS = Object.freeze(['rescore', 'move_kind', 'add_source', 'correct_entry', 'remove_item']);
+const PROPOSAL_KINDS = Object.freeze([...ITEM_KINDS, 'add_item']);
+
+const num = (v) => (v == null ? null : Number(v));
+const isoDay = (d) => (d instanceof Date ? d.toISOString().slice(0, 10) : String(d).slice(0, 10));
+
+// ---- reads only these pages need -------------------------------------------
+
+const LATEST_SCORES_SQL = `
+  SELECT DISTINCT ON (s.item_id, s.dimension) s.item_id, s.dimension, s.value
+    FROM market_watch_score_snapshots s
+    JOIN market_watch_items i ON i.id = s.item_id
+    JOIN market_watch_runs r ON r.id = s.run_id
+   WHERE i.project = $1 AND i.status <> 'removed'
+   ORDER BY s.item_id, s.dimension, r.created_at DESC, r.id DESC`;
+
+async function latestScores(pool, { project }) {
+  const { rows } = await pool.query(LATEST_SCORES_SQL, [project]);
+  return rows;
+}
+
+const WEEK_ENTRIES_SQL = `
+  SELECT e.id, e.item_id, e.run_id, e.type, e.found_on, e.takeaway, e.confidence,
+         e.source_url, e.source_label, e.pinned
+    FROM market_watch_log_entries e
+    JOIN market_watch_items i ON i.id = e.item_id
+   WHERE i.project = $1 AND i.status <> 'removed' AND e.found_on >= $2::date
+   ORDER BY e.found_on DESC, e.id DESC
+   LIMIT 1000`;
+
+async function weekEntries(pool, { project, now = new Date() }) {
+  const since = isoDay(new Date(new Date(now).getTime() - WEEK_DAYS * DAY_MS));
+  const { rows } = await pool.query(WEEK_ENTRIES_SQL, [project, since]);
+  return rows;
+}
+
+// ---- pure shapes ------------------------------------------------------------
+
+// The labels a kind's dimensions carry, from the rules in use: { <key>: label }.
+function rubricLabels(rules, kind) {
+  const rubric = (rules && rules.active && rules.active.rubric) || {};
+  const out = {};
+  for (const d of Array.isArray(rubric[kind]) ? rubric[kind] : []) if (d && d.key) out[d.key] = String(d.label || d.key);
+  return out;
+}
+
+// One report per item: a pinned entry first, then the surest, then an insight over a
+// datapoint, then the newest. Items ordered by their overall score, best first.
+const TYPE_RANK = { insight: 0, news: 1, datapoint: 2 };
+function pickReports(entries, itemsById, limit = REPORT_LIMIT) {
+  const best = new Map();
+  const better = (a, b) => (Number(!!b.pinned) - Number(!!a.pinned))
+    || (Number(b.confidence) - Number(a.confidence))
+    || ((TYPE_RANK[a.type] ?? 3) - (TYPE_RANK[b.type] ?? 3))
+    || (isoDay(b.found_on) > isoDay(a.found_on) ? 1 : isoDay(b.found_on) < isoDay(a.found_on) ? -1 : 0)
+    || (Number(b.id) - Number(a.id));
+  for (const e of entries) {
+    const it = itemsById.get(String(e.item_id));
+    if (!it) continue;
+    const k = String(e.item_id);
+    if (!best.has(k) || better(e, best.get(k)) < 0) best.set(k, e);
+  }
+  const all = [...best.values()]
+    .map((e) => {
+      const it = itemsById.get(String(e.item_id));
+      return {
+        id: Number(e.id),
+        item_id: Number(e.item_id),
+        item_name: it.name,
+        kind: it.kind,
+        overall: it.overall,
+        type: e.type,
+        takeaway: e.takeaway,
+        confidence: Number(e.confidence),
+        found_on: isoDay(e.found_on),
+        source_url: e.source_url,
+      };
+    })
+    .sort((a, b) => ((b.overall ?? -1) - (a.overall ?? -1)) || a.item_name.localeCompare(b.item_name));
+  // Competitors and partners are scored on different scales, so one ranking across both
+  // would be a false comparison: take each kind's best in turn instead.
+  const queues = KINDS.map((k) => all.filter((r) => r.kind === k));
+  const out = [];
+  while (out.length < limit && queues.some((q) => q.length)) {
+    for (const q of queues) if (q.length && out.length < limit) out.push(q.shift());
+  }
+  return out;
+}
+
+// shapeHome — the watchtower desk: scouts, the run streak, the next sweep and budget,
+// the landscape's axes and dots, and this week's reports.
+function shapeHome({ items, runs, settings, scores, entries, rules, now = new Date() }) {
+  const live = items.filter((it) => it.status !== 'removed');
+  const itemsById = new Map(live.map((it) => [String(it.id), it]));
+  const reports = pickReports(entries, itemsById);
+  const weekByKind = {};
+  for (const e of entries) {
+    const it = itemsById.get(String(e.item_id));
+    if (it) (weekByKind[it.kind] = weekByKind[it.kind] || new Set()).add(String(it.id));
+  }
+  const scouts = KINDS.map((kind) => {
+    const mine = live.filter((it) => it.kind === kind);
+    return {
+      kind,
+      watched: mine.filter((it) => it.status === 'active').length,
+      level: mine.reduce((m, it) => Math.max(m, it.level || 0), 0),
+      reports: weekByKind[kind] ? weekByKind[kind].size : 0,
+    };
+  });
+  const ranRuns = runs.filter((r) => r.n != null);
+  const streak = runs.slice(-STREAK_SLOTS).map((r) => ({ n: r.n, ran: r.n != null, date: isoDay(r.created_at), reason: r.reason || null }));
+
+  const labels = rubricLabels(rules, 'competitor');
+  const byItem = new Map();
+  for (const s of scores) {
+    const k = String(s.item_id);
+    if (!byItem.has(k)) byItem.set(k, {});
+    byItem.get(k)[s.dimension] = num(s.value);
+  }
+  const seen = new Set(Object.keys(labels));
+  const dots = live.filter((it) => it.kind === 'competitor').map((it) => {
+    const sc = byItem.get(String(it.id)) || {};
+    for (const k of Object.keys(sc)) if (k !== 'overall') seen.add(k);
+    return { id: it.id, name: it.name, overall: it.overall, level: it.level, scores: sc };
+  });
+  const axes = [...seen].map((key) => ({ key, label: labels[key] || key.replace(/_/g, ' ') }));
+  axes.push({ key: 'overall', label: 'overall likeness' });
+
+  const s = settings.settings;
+  const cap = Number(s.monthly_cap_usd) || 0;
+  const spent = Number(settings.spentThisMonthUsd) || 0;
+  return {
+    generated_at: new Date(now).toISOString(),
+    watch: { enabled: !!s.enabled, configured: !!s.configured, cadence: s.cadence },
+    weeks_watched: ranRuns.length,
+    scouts,
+    streak,
+    next_sweep: { due: settings.nextRunDue ? new Date(settings.nextRunDue).toISOString() : null, enabled: !!s.enabled },
+    budget: { cap_usd: cap, spent_usd: Math.round(spent * 100) / 100, left_usd: Math.max(0, Math.round((cap - spent) * 100) / 100) },
+    axes,
+    dots,
+    reports,
+    hot: reports.map((r) => r.item_id),
+    // Every tracked item by name: the desk's "open a file" picker, the way to any item
+    // page that is not a dot (a partner, a topic) or a report this week.
+    index: live.map((it) => ({ id: it.id, kind: it.kind, name: it.name }))
+      .sort((a, b) => (KINDS.indexOf(a.kind) - KINDS.indexOf(b.kind)) || a.name.localeCompare(b.name)),
+  };
+}
+
+// shapeItem — the dossier: the card (level, streak, overall line, one sparkline per
+// dimension), why it is watched, its known facts and the sortable case file.
+function shapeItem({ item, entries, history, rules, openProposals = 0 }) {
+  const labels = rubricLabels(rules, item.kind);
+  const series = history.series || {};
+  const keys = [...Object.keys(labels), ...Object.keys(series).filter((k) => k !== 'overall' && !(k in labels))];
+  const point = (vals) => {
+    const v = (vals || []).filter((x) => x != null);
+    return { first: v.length ? v[0] : null, latest: v.length ? v[v.length - 1] : null };
+  };
+  const dimensions = keys.map((key) => ({ key, label: labels[key] || key.replace(/_/g, ' '), series: series[key] || [], ...point(series[key]) }));
+  return {
+    item: {
+      id: item.id, kind: item.kind, name: item.name, url: item.url, category: item.category,
+      description: item.description, why_tracked: item.why_tracked, facts: item.facts || {},
+      status: item.status, added_via: item.added_via, created_at: item.created_at,
+      overall: item.overall, level: item.level, streak: item.streak,
+    },
+    runs: (history.runs || []).map((r) => ({ n: r.n, date: isoDay(r.date) })),
+    overall: { series: series.overall || [], ...point(series.overall) },
+    dimensions,
+    moved: dimensions.filter((d) => d.first != null && d.latest != null && d.first !== d.latest).length,
+    entries: entries.map((e) => ({
+      id: Number(e.id), run: e.run, type: e.type, found_on: isoDay(e.found_on), takeaway: e.takeaway,
+      dimension: e.dimension, source_url: e.source_url, source_label: e.source_label,
+      confidence: Number(e.confidence), pinned: !!e.pinned,
+    })),
+    open_proposals: Number(openProposals) || 0,
+  };
+}
+
+// ---- the views --------------------------------------------------------------
+
+// Each view reads the numbered runs ONCE and hands them to every db.js read that would
+// otherwise read market_watch_runs again (listItems, getItem, caseFile, scoreHistory).
+async function homeView(pool, { project, now = new Date() }) {
+  const runs = await db.numberedRuns(pool, { project });
+  const [items, settings, scores, entries, rules] = await Promise.all([
+    db.listItems(pool, { project, knownRuns: runs }),
+    db.settingsView(pool, { project, now }),
+    latestScores(pool, { project }),
+    weekEntries(pool, { project, now }),
+    db.rules(pool, { project }),
+  ]);
+  return shapeHome({ items, runs, settings, scores, entries, rules, now });
+}
+
+async function itemView(pool, { project, id }) {
+  const runs = await db.numberedRuns(pool, { project });
+  const item = await db.getItem(pool, { project, id, knownRuns: runs });
+  if (!item) return null;
+  const [entries, history, rules, open] = await Promise.all([
+    db.caseFile(pool, { project, itemId: id, knownRuns: runs }),
+    db.scoreHistory(pool, { project, itemId: id, knownRuns: runs }),
+    db.rules(pool, { project }),
+    db.proposals(pool, { project, status: 'open', itemId: id, limit: 100 }),
+  ]);
+  return shapeItem({ item, entries, history, rules, openProposals: open.length });
+}
+
+// ---- proposals --------------------------------------------------------------
+
+const oneLine = (s) => String(s == null ? '' : s).replace(/[\u0000-\u001f\u007f]+/g, ' ').replace(/\s+/g, ' ').trim();
+const isHttp = (u) => /^https?:\/\/[^\s/]+\.[^\s]+$/i.test(u);
+
+// normalizeProposal(body, { item, rubricKeys }) → { ok, value } | { ok: false, error, message }.
+// `item` is the tracked item the proposal is about (null for add_item); rubricKeys is the
+// set of dimensions the item's kind is scored on. Everything a member typed is trimmed
+// to one line and bounded; nothing here trusts the client's idea of the item's kind.
+function normalizeProposal(body, { item = null, rubricKeys = null } = {}) {
+  const b = body && typeof body === 'object' ? body : {};
+  const kind = String(b.kind || '');
+  if (!PROPOSAL_KINDS.includes(kind)) return { ok: false, error: 'invalid_kind', message: 'Pick what should change.' };
+  const reason = oneLine(b.reason);
+  if (!reason) return { ok: false, error: 'reason_required', message: 'Say why, in one line.' };
+  if (reason.length > REASON_MAX) return { ok: false, error: 'reason_too_long', message: `Keep the reason to ${REASON_MAX} characters.` };
+  if (kind === 'add_item') {
+    const name = oneLine(b.name);
+    const scout = String(b.scout || '');
+    const url = oneLine(b.url);
+    if (!KINDS.includes(scout)) return { ok: false, error: 'invalid_scout', message: 'Pick a competitor, a partner or a topic.' };
+    if (!name || name.length > NAME_MAX) return { ok: false, error: 'invalid_name', message: `Name it in up to ${NAME_MAX} characters.` };
+    if (url && (url.length > URL_MAX || !isHttp(url))) return { ok: false, error: 'invalid_url', message: 'A link starts with http:// or https://.' };
+    return { ok: true, value: { kind, item_id: null, log_entry_id: null, reason, payload: { kind: scout, name, url: url || null } } };
+  }
+  if (!item) return { ok: false, error: 'item_not_found', message: 'That item is not tracked here.' };
+  const base = { kind, item_id: item.id, log_entry_id: null, reason };
+  if (kind === 'rescore') {
+    const dimension = String(b.dimension || '');
+    const value = Number(b.value);
+    const known = dimension === 'overall' || (rubricKeys ? rubricKeys.has(dimension) : DIM_RE.test(dimension));
+    if (!DIM_RE.test(dimension) || !known) return { ok: false, error: 'invalid_dimension', message: 'Pick a score to change.' };
+    if (b.value === '' || b.value == null || !Number.isFinite(value) || value < 0 || value > 10) return { ok: false, error: 'invalid_value', message: 'A score is from 0 to 10.' };
+    return { ok: true, value: { ...base, payload: { dimension, value: Math.round(value * 10) / 10 } } };
+  }
+  if (kind === 'move_kind') {
+    if (item.kind === 'topic') return { ok: false, error: 'cannot_move_topic', message: 'A topic is not a partner or a competitor.' };
+    return { ok: true, value: { ...base, payload: { from: item.kind, to: item.kind === 'partner' ? 'competitor' : 'partner' } } };
+  }
+  if (kind === 'add_source') {
+    const url = oneLine(b.url);
+    if (!url || url.length > URL_MAX || !isHttp(url)) return { ok: false, error: 'invalid_url', message: 'A source is a link that starts with http:// or https://.' };
+    return { ok: true, value: { ...base, payload: { source_url: url } } };
+  }
+  if (kind === 'correct_entry') {
+    const entry = String(b.log_entry_id || '');
+    if (!/^[1-9]\d{0,17}$/.test(entry)) return { ok: false, error: 'invalid_entry', message: 'Pick the entry to correct.' };
+    return { ok: true, value: { ...base, log_entry_id: Number(entry), payload: {} } };
+  }
+  return { ok: true, value: { ...base, payload: {} } }; // remove_item: stop tracking
+}
+
+// The INSERT checks ownership in SQL: the item must be this project's, and an entry to
+// correct must be that item's. A row from another project inserts nothing.
+const INSERT_ITEM_PROPOSAL_SQL = `
+  INSERT INTO market_watch_proposals (project, kind, origin, item_id, log_entry_id, payload, reason, proposed_by)
+  SELECT $1, $2, 'member', i.id, $4, $5::jsonb, $6, $7
+    FROM market_watch_items i
+   WHERE i.id = $3 AND i.project = $1
+     AND ($4::bigint IS NULL OR EXISTS (SELECT 1 FROM market_watch_log_entries e WHERE e.id = $4 AND e.item_id = i.id))
+  RETURNING id, kind, status, created_at`;
+const INSERT_NEW_ITEM_PROPOSAL_SQL = `
+  INSERT INTO market_watch_proposals (project, kind, origin, payload, reason, proposed_by)
+  VALUES ($1, 'add_item', 'member', $2::jsonb, $3, $4)
+  RETURNING id, kind, status, created_at`;
+
+async function insertProposal(pool, { project, proposal, builderId }) {
+  const p = proposal;
+  const { rows: [row] } = p.kind === 'add_item'
+    ? await pool.query(INSERT_NEW_ITEM_PROPOSAL_SQL, [project, JSON.stringify(p.payload), p.reason, builderId])
+    : await pool.query(INSERT_ITEM_PROPOSAL_SQL, [project, p.kind, p.item_id, p.log_entry_id, JSON.stringify(p.payload), p.reason, builderId]);
+  return row ? { ...row, id: Number(row.id) } : null;
+}
+
+module.exports = {
+  homeView, itemView, insertProposal,
+  shapeHome, shapeItem, pickReports, rubricLabels, normalizeProposal,
+  PROPOSAL_KINDS, KINDS,
+};