@bongos/core 1.24.3 → 1.24.5

package/modules/lifecycle/db-ship.js

@@ -16,7 +16,7 @@ const log = api.logger('lifecycle');
 const seams = api;
 const doneWhen = require('./done-when.js');
 const { THETES_GRADUATION_THRESHOLD, maybeAutoGraduateToThetes, foldWorktreeName } = require('./db-rank-authz.js');
-const { mostRecentClaimHolderId, sealSessionLog, staleClaimHourPredicate } = require('./db-shared.js');
+const { idKey, mostRecentClaimHolderId, sealSessionLog, staleClaimHourPredicate } = require('./db-shared.js');
 const { LIVE_STATUSES } = require('./dead-deps.js');
 const { isPageTweak } = require('./page-tweak-hold.js');
 const pageTweakArtist = require('./page-tweak-artist.js');
@@ -138,7 +138,7 @@ async function resolveClaim({ claimId, builderId, outcome, notesMd, valueSummary
     );
     if (claimRows.length === 0) throw { code: 'CLAIM_NOT_FOUND' };
     const claim = claimRows[0];
-    if (claim.builder_id !== builderId) throw { code: 'NOT_YOUR_CLAIM' };
+    if (idKey(claim.builder_id) !== idKey(builderId)) throw { code: 'NOT_YOUR_CLAIM' }; // task 1005004: pg bigint string vs a number
     if (claim.released_at) throw { code: 'ALREADY_RESOLVED' };
     // Resolve lock: only the WORKING TREE that created this claim can resolve it
     // (task 1003767) — falling back to the creating session where no tree is

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

@@ -114,8 +114,10 @@ function creditRow() {
     };
   }
   const mult = (1 + Number(policy.marginPct) / 100).toFixed(2);
-  const peg = Number(policy.usdPeg);
-  const pegNote = peg !== 1 ? ` × ${peg} peg` : '';
+  // `costScale` (task 1004968; formerly `usdPeg`) is a sizing factor, not an
+  // exchange rate — so the sentence says "scale", never "peg" (ADR 0387).
+  const scale = Number(policy.costScale);
+  const pegNote = Number.isFinite(scale) && scale !== 1 ? ` × ${scale} scale` : '';
   // The per-task estimate is ADVERTISED but never paid when the mode is cost-plus-only
   // (ADR 0146). A page that showed the estimate without that sentence would be telling
   // a builder they will earn a number this instance has decided not to pay.
@@ -129,7 +131,7 @@ function creditRow() {
     title: 'Credit calculation',
     editable: false,
     state: 'live',
-    value: { marginPct: policy.marginPct, usdPeg: policy.usdPeg, mode: policy.mode, perTaskCredit: policy.perTaskCredit },
+    value: { marginPct: policy.marginPct, costScale: policy.costScale, mode: policy.mode, perTaskCredit: policy.perTaskCredit },
     sentence: `A shipped session earns round(true cost in USD × ${mult}${pegNote}) credits, sized by the session’s cost in USD. Credits measure contribution; they are not money. ${estimate}`,
     source: 'branding pack → `reward`',
     reads: { file: 'config/branding.json → reward', adr: 'ADR 0054, ADR 0146' },
@@ -246,7 +248,7 @@ module.exports = function buildProjectSettingsRouter() {
   // rank: project.settings.manage (metic+, government_010), the SAME floor as the page
   // it serves (requireGovernmentPage). The first cut gated this any-builder on the
   // reasoning that it is "the project's own published terms" — but the payload also
-  // carries reward-policy internals (marginPct, usdPeg, mode), a raw rejected
+  // carries reward-policy internals (marginPct, costScale, mode), a raw rejected
   // project_settings value, and internal file/migration paths, and a xenos who cannot
   // even load the page could still curl those. Matching the read floor to the page's
   // (task 1003280 grade, hacker lens) closes that asymmetry; the two WRITES already

package/modules/market-watch/ask.js

@@ -0,0 +1,425 @@
+'use strict';
+
+// modules/market-watch/ask.js — the weekly ask card (task 1004940, goal 1000137).
+//
+// Once a week every member of a project with Market Watch on gets one short card with two
+// questions: "what counts as a competitor?" and "what else should we watch?". Each shows
+// chips drawn from the project's OWN tracked items, plus a free "name one" / "add a topic"
+// entry. Design of record: docs/design/mocks/market-watch/weekly-ask.html (option A).
+//
+//   issueWeeklyAsk  the poller's half (pollers/weekly-ask.js): this week's two question rows,
+//                   created once per project per week by the UNIQUE (project, week_of,
+//                   question_key) constraint, so a second tick or a second process is a no-op
+//   cardFor         the member's card, or null: no ask this week, the ask has closed, or
+//                   they already answered. A closed ask is simply not shown — it expires
+//                   quietly, and nothing ever reminds anyone (the owner's "no nagging")
+//   answer          a member's taps and entries, stored as market_watch_ask_answers rows
+//                   and POOLED into proposals
+//
+// POOLING. Similar answers are the same name or topic once normalised (`normalise`: case,
+// accents' width forms, punctuation and a leading article do not count). The pool key is
+// `<question>|<normalised choice>`. The first answer with a key files ONE
+// market_watch_proposals row (origin 'weekly_ask', answer_id = that answer, payload.pool_key
+// = the key); every later answer with the key joins it instead. The agree count is DERIVED
+// (the distinct members whose answers carry the key), never a stored number to keep true.
+// The pool lock is a transaction-scoped advisory lock on the key, so two members tapping
+// the same chip at once still file one proposal.
+//
+// What each answer proposes:
+//   a competitor chip ("AI app builder")  rule_change: count that kind of company as a
+//                                         competitor (it points at the rules version in use;
+//                                         with no rules in use there is nothing to change,
+//                                         so the answer is kept and files no proposal)
+//   "name one" ("Kilo Code")              add_item: track it as a competitor
+//   a watch chip or "add a topic"         add_item: track it as a topic
+//
+// UNTRUSTED TEXT. Free entries are a member's words: cleaned (control characters out,
+// whitespace collapsed), capped at MAX_TEXT, and only ever escaped where they are drawn
+// (public/hall-widget.js). They never reach an AI prompt from here.
+//
+// Everything below the pure helpers takes a `store` (createAskStore(pool) for Postgres),
+// so the whole flow is tested with an in-memory store and no database.
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const MAX_TEXT = 80;          // a name or a topic, not a paragraph
+const MAX_PICKS = 20;         // more chips than both questions ever show
+const MAX_NAMES = 6;          // free entries per answer
+const RIVAL_CHIPS = 5;
+const WATCH_CHIPS = 4;
+const NOTHING = '~nothing';   // "Nothing new this week": normalise() never yields a '~'
+
+const QUESTIONS = Object.freeze([
+  Object.freeze({ key: 'rival', prompt: 'what counts as a competitor?' }),
+  Object.freeze({ key: 'watch', prompt: 'what else should we watch?' }),
+]);
+const QUESTION_KEYS = Object.freeze(QUESTIONS.map((q) => q.key));
+
+// ---- pure helpers ---------------------------------------------------------
+
+// weekStart(now) → 'YYYY-MM-DD', the Monday (UTC) of now's week: the ask's week_of.
+function weekStart(now = new Date()) {
+  const d = new Date(now);
+  const day = (d.getUTCDay() + 6) % 7; // Monday 0 … Sunday 6
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() - day)).toISOString().slice(0, 10);
+}
+
+// isoWeek(weekOf) → the ISO week number the card names ("week 44").
+function isoWeek(weekOf) {
+  const d = new Date(`${String(weekOf).slice(0, 10)}T00:00:00Z`);
+  const thursday = new Date(d.getTime() + (3 - ((d.getUTCDay() + 6) % 7)) * DAY_MS);
+  const jan1 = Date.UTC(thursday.getUTCFullYear(), 0, 1);
+  return 1 + Math.floor((thursday.getTime() - jan1) / (7 * DAY_MS));
+}
+
+const dateOnly = (v) => (v instanceof Date ? v.toISOString().slice(0, 10) : String(v).slice(0, 10));
+const addDays = (weekOf, n) => new Date(Date.parse(`${dateOnly(weekOf)}T00:00:00Z`) + n * DAY_MS);
+
+// Control characters, zero-width marks and direction overrides: never part of a name, and
+// a direction override can make one entry read as another.
+const HIDDEN = [[0x00, 0x1f], [0x7f, 0x9f], [0x200b, 0x200f], [0x2028, 0x202e], [0x2066, 0x2069], [0xfeff, 0xfeff]];
+const isHidden = (c) => HIDDEN.some(([a, b]) => c >= a && c <= b);
+
+// cleanText(s) → a member's entry as it may be stored and shown, or '' for nothing.
+function cleanText(s) {
+  if (typeof s !== 'string') return '';
+  let out = '';
+  for (const ch of s.normalize('NFKC')) out += isHidden(ch.codePointAt(0)) ? ' ' : ch;
+  return out
+    .replace(/\s+/g, ' ').trim();
+}
+
+// normalise(s) → the pooling key: lower case, letters and digits only, one space between
+// words, no leading article. "Kilo Code", " kilo-code ", "The Kilo Code!" pool together.
+function normalise(s) {
+  return cleanText(String(s == null ? '' : s)).toLowerCase()
+    .replace(/[^\p{L}\p{N}]+/gu, ' ').trim()
+    .replace(/^(the|a|an) (?=\S)/, '')
+    .slice(0, MAX_TEXT);
+}
+
+const poolKey = (question, choice) => `${question}|${choice}`;
+
+// shortName("Cognition (Devin)") → "Cognition": a chip's example stays short.
+const shortName = (n) => String(n || '').replace(/\s*\(.*\)\s*$/, '').split(' / ')[0].trim();
+const capFirst = (s) => (s ? s[0].toUpperCase() + s.slice(1) : s);
+
+function topCategories(items, limit, skip = new Set()) {
+  const by = new Map();
+  for (const it of items) {
+    const label = cleanText(it.category || '');
+    if (!label) continue;
+    const k = normalise(label);
+    if (!k || skip.has(k)) continue;
+    if (!by.has(k)) by.set(k, { label: capFirst(label).slice(0, 48), names: [] });
+    by.get(k).names.push(shortName(it.name));
+  }
+  return [...by.values()]
+    .sort((a, b) => b.names.length - a.names.length || a.label.localeCompare(b.label))
+    .slice(0, limit)
+    .map((c) => ({ label: c.label, example: c.names.filter(Boolean).slice(0, 2).join(', ').slice(0, 48) }));
+}
+
+// chipOptions(items) → { rival: [...], watch: [...] }, each chip { label, example }, drawn
+// from the project's own active items. Competitor chips are the kinds of company it already
+// tracks as competitors, most-tracked first. Watch chips are the areas its partners sit in
+// that it does not already watch as a topic or ask about as a competitor kind.
+function chipOptions(items) {
+  const list = (items || []).filter((i) => i && i.status !== 'removed');
+  const rival = topCategories(list.filter((i) => i.kind === 'competitor'), RIVAL_CHIPS);
+  const skip = new Set([
+    ...rival.map((c) => normalise(c.label)),
+    ...list.filter((i) => i.kind === 'topic').map((i) => normalise(i.name)),
+  ]);
+  const watch = topCategories(list.filter((i) => i.kind === 'partner'), WATCH_CHIPS, skip);
+  return { rival, watch };
+}
+
+// parseAnswer(body) → { entries, nothing } or { error, status }. An entry is
+// { question, choice (the normalised key), label (what it shows as), free (bool) }.
+// Chips are matched against the ask's own options in answer(); here only the shape.
+function parseAnswer(body) {
+  const bad = (code, message) => ({ error: code, status: 400, message });
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return bad('bad_answer', 'An answer is an object.');
+  const picks = body.picks == null ? [] : body.picks;
+  const names = body.names == null ? [] : body.names;
+  if (!Array.isArray(picks) || !Array.isArray(names)) return bad('bad_answer', 'picks and names are lists.');
+  if (picks.length > MAX_PICKS || names.length > MAX_NAMES) return bad('too_many', 'That is more than the card offers.');
+  const entries = [];
+  for (const [list, free] of [[picks, false], [names, true]]) {
+    for (const e of list) {
+      if (!e || typeof e !== 'object') return bad('bad_answer', 'Each answer names its question.');
+      const question = e.question;
+      if (!QUESTION_KEYS.includes(question)) return bad('unknown_question', 'There is no such question on this card.');
+      const raw = typeof e[free ? 'text' : 'choice'] === 'string' ? e[free ? 'text' : 'choice'] : '';
+      if (raw.length > MAX_TEXT * 4) return bad('text_too_long', `Keep it under ${MAX_TEXT} characters.`);
+      const label = cleanText(raw);
+      if (label.length > MAX_TEXT) return bad('text_too_long', `Keep it under ${MAX_TEXT} characters.`);
+      const choice = normalise(label);
+      if (!choice) return bad('empty_answer', 'An entry needs a name or a topic.');
+      entries.push({ question, choice, label, free });
+    }
+  }
+  const nothing = body.nothing === true;
+  if (!entries.length && !nothing) return bad('empty_answer', 'Pick at least one, or say nothing new this week.');
+  return { entries, nothing: nothing && !entries.length };
+}
+
+// proposalFor(entry, ruleVersionId) → the proposal a NEW pool files, or null.
+function proposalFor(entry, ruleVersionId) {
+  if (entry.question === 'rival' && !entry.free) {
+    if (ruleVersionId == null) return null;
+    return { kind: 'rule_change', ruleVersionId, payload: { change: 'competitor_definition', include: entry.label } };
+  }
+  const itemKind = entry.question === 'rival' ? 'competitor' : 'topic';
+  return { kind: 'add_item', ruleVersionId: null, payload: { item_kind: itemKind, name: entry.label } };
+}
+
+// teamRow(p) → one line of "this week's proposals from the team", as data the page escapes:
+// verb, the name in bold, the tail, who filed it first, how many agree, and its status.
+function teamRow(p) {
+  const pl = p.payload || {};
+  let row;
+  // "competitor", the card's own word for it (the mock's rows said "rival"; one word per screen).
+  if (p.kind === 'rule_change') row = { verb: 'Count', name: pl.include || '', tail: 'as a competitor' };
+  else if (pl.item_kind === 'competitor') row = { verb: 'Add', name: pl.name || '', tail: 'as a competitor' };
+  else row = { verb: 'Watch', name: pl.name || '', tail: '' };
+  return { id: Number(p.id), ...row, who: p.who || null, agree: Number(p.agree) || 0, status: p.status };
+}
+
+// ---- the flow ---------------------------------------------------------------
+
+// issueWeeklyAsk — this week's questions, once. Returns how many rows it created (0 when the
+// week's ask is already out). Chips are a snapshot of the project's data at issue time, so a
+// card reads the same all week.
+async function issueWeeklyAsk(store, { project, now = new Date() }) {
+  const weekOf = weekStart(now);
+  const existing = await store.asksForWeek(project, weekOf);
+  if (existing.length >= QUESTIONS.length) return { weekOf, created: 0 };
+  const chips = chipOptions(await store.chipSource(project));
+  const closesAt = addDays(weekOf, 7);
+  let created = 0;
+  for (const q of QUESTIONS) {
+    if (await store.insertAsk(project, { weekOf, questionKey: q.key, prompt: q.prompt, options: chips[q.key], closesAt })) created += 1;
+  }
+  return { weekOf, created };
+}
+
+function openAsks(asks, now) {
+  const t = new Date(now).getTime();
+  return asks.filter((a) => !a.closes_at || new Date(a.closes_at).getTime() > t);
+}
+
+// cardFor — the member's card for this week, or null (nothing to show: no ask, closed, or
+// already answered). The answered check is per WEEK: one answer to either question is
+// the week answered.
+async function cardFor(store, { project, builderId, now = new Date() }) {
+  const weekOf = weekStart(now);
+  const asks = openAsks(await store.asksForWeek(project, weekOf), now);
+  if (!asks.length) return null;
+  if (await store.answeredWeek(project, weekOf, builderId)) return null;
+  const [streak, team] = await Promise.all([
+    store.streak(project, builderId, now),
+    store.teamProposals(project, weekOf),
+  ]);
+  const byKey = new Map(asks.map((a) => [a.question_key, a]));
+  return {
+    week_of: weekOf,
+    week_no: isoWeek(weekOf),
+    closes_at: asks[0].closes_at,
+    next_on: addDays(weekOf, 7).toISOString().slice(0, 10),
+    streak,
+    questions: QUESTIONS.filter((q) => byKey.has(q.key)).map((q) => ({
+      key: q.key,
+      prompt: byKey.get(q.key).prompt,
+      options: (byKey.get(q.key).options || []).map((o) => ({ label: String(o.label || ''), example: String(o.example || '') })),
+    })),
+    team: team.map(teamRow),
+  };
+}
+
+// answer — store a member's answer and pool it. `builderId` is ALWAYS the caller (the route
+// passes req.builder.id); nothing in the body can name another member.
+// Returns { status, body }.
+async function answer(store, { project, builderId, body, now = new Date() }) {
+  const parsed = parseAnswer(body);
+  if (parsed.error) return { status: parsed.status, body: { error: { code: parsed.error, message: parsed.message } } };
+  const weekOf = weekStart(now);
+  const closed = { status: 409, body: { error: { code: 'ask_closed', message: "This week's ask has closed." } } };
+  if (body.week_of != null && String(body.week_of).slice(0, 10) !== weekOf) return closed;
+  const asks = openAsks(await store.asksForWeek(project, weekOf), now);
+  const byKey = new Map(asks.map((a) => [a.question_key, a]));
+  if (!byKey.size) return closed;
+
+  // A chip must be one the card offered; its stored label is the option's own, not the body's.
+  for (const e of parsed.entries) {
+    const ask = byKey.get(e.question);
+    if (!ask) return closed;
+    if (e.free) continue;
+    const opt = (ask.options || []).find((o) => normalise(o.label) === e.choice);
+    if (!opt) return { status: 400, body: { error: { code: 'unknown_choice', message: 'That chip is not on this card.' } } };
+    e.label = cleanText(String(opt.label)).slice(0, MAX_TEXT);
+  }
+
+  const ruleVersionId = await store.activeRuleVersionId(project);
+  const result = await store.tx(async (tx) => {
+    const out = { answers: 0, proposals: 0, pooled: 0 };
+    if (parsed.nothing) {
+      const first = byKey.get('rival') || asks[0];
+      if (await tx.insertAnswer({ project, askId: first.id, builderId, choice: NOTHING, freeText: null })) out.answers += 1;
+      return out;
+    }
+    for (const e of parsed.entries) {
+      const ask = byKey.get(e.question);
+      const answerId = await tx.insertAnswer({ project, askId: ask.id, builderId, choice: e.choice, freeText: e.free ? e.label : null });
+      if (!answerId) continue; // already tapped this one: a no-op
+      out.answers += 1;
+      const key = poolKey(e.question, e.choice);
+      await tx.lockPool(project, key);
+      if (await tx.findPooled(project, key)) { out.pooled += 1; continue; }
+      const spec = proposalFor(e, ruleVersionId);
+      if (!spec) continue;
+      await tx.insertProposal({
+        project,
+        kind: spec.kind,
+        ruleVersionId: spec.ruleVersionId,
+        answerId,
+        proposedBy: builderId,
+        payload: { ...spec.payload, pool_key: key, question: e.question, choice: e.choice },
+        reason: `From the weekly ask, week of ${weekOf}.`,
+      });
+      out.proposals += 1;
+    }
+    return out;
+  });
+  return { status: 200, body: { ok: true, week_of: weekOf, ...result } };
+}
+
+// ---- the Postgres store -----------------------------------------------------
+
+const ASKS_SQL = `
+  SELECT id, question_key, prompt, options, closes_at
+    FROM market_watch_weekly_asks WHERE project = $1 AND week_of = $2::date
+   ORDER BY question_key`;
+const INSERT_ASK_SQL = `
+  INSERT INTO market_watch_weekly_asks (project, week_of, question_key, prompt, options, closes_at)
+  VALUES ($1, $2::date, $3, $4, $5::jsonb, $6)
+  ON CONFLICT (project, week_of, question_key) DO NOTHING
+  RETURNING id`;
+const CHIP_SOURCE_SQL = `
+  SELECT kind, name, category, status FROM market_watch_items
+   WHERE project = $1 AND status = 'active' ORDER BY id`;
+const ANSWERED_SQL = `
+  SELECT EXISTS (SELECT 1 FROM market_watch_ask_answers x
+                   JOIN market_watch_weekly_asks a ON a.id = x.ask_id
+                  WHERE a.project = $1 AND a.week_of = $2::date AND x.builder_id = $3) AS answered`;
+const ACTIVE_RULES_SQL = `SELECT id FROM market_watch_rule_versions WHERE project = $1 AND status = 'active' LIMIT 1`;
+// The answer's ask must be the project's: the guard is in the statement, not only the caller.
+const INSERT_ANSWER_SQL = `
+  INSERT INTO market_watch_ask_answers (ask_id, builder_id, choice, free_text)
+  SELECT a.id, $3, $4, $5 FROM market_watch_weekly_asks a WHERE a.id = $2 AND a.project = $1
+  ON CONFLICT (ask_id, builder_id, choice) DO NOTHING
+  RETURNING id`;
+// A pool already holds a proposal unless the one it held was turned down or withdrawn.
+// Served by market_watch_proposals_ask_pool (migration 003), not a scan.
+const FIND_POOLED_SQL = `
+  SELECT id FROM market_watch_proposals
+   WHERE project = $1 AND origin = 'weekly_ask' AND payload->>'pool_key' = $2
+     AND status IN ('open', 'approved', 'applied')
+   LIMIT 1`;
+const INSERT_PROPOSAL_SQL = `
+  INSERT INTO market_watch_proposals (project, kind, origin, rule_version_id, answer_id, payload, reason, proposed_by)
+  VALUES ($1, $2, 'weekly_ask', $3, $4, $5::jsonb, $6, $7)
+  RETURNING id`;
+// This week's weekly-ask proposals with their derived agree count: the distinct members
+// whose answers carry the proposal's question and choice. The count is NOT limited to this
+// week on purpose: a pool outlives the week it was opened in, and a member who named the
+// same rival last week still agrees. It is indexed both ways: the project's asks by
+// UNIQUE (project, week_of, question_key), their answers by UNIQUE (ask_id, builder_id,
+// choice) — plain column equalities, no computed string. At most five rows are counted.
+const TEAM_SQL = `
+  SELECT p.id, p.kind, p.payload, p.status,
+         COALESCE(NULLIF(b.display_name, ''), b.github_login) AS who,
+         (SELECT count(DISTINCT x.builder_id)
+            FROM market_watch_weekly_asks a
+            JOIN market_watch_ask_answers x ON x.ask_id = a.id AND x.choice = p.payload->>'choice'
+           WHERE a.project = p.project AND a.question_key = p.payload->>'question')::int AS agree
+    FROM market_watch_proposals p
+    LEFT JOIN builders b ON b.id = p.proposed_by
+   WHERE p.project = $1 AND p.origin = 'weekly_ask' AND p.created_at >= $2::date
+     AND p.status IN ('open', 'approved', 'applied')
+   ORDER BY agree DESC, p.created_at DESC, p.id DESC
+   LIMIT $3`;
+
+function queriesOn(q) {
+  return {
+    async insertAnswer({ project, askId, builderId, choice, freeText }) {
+      const { rows: [r] } = await q.query(INSERT_ANSWER_SQL, [project, askId, builderId, choice, freeText]);
+      return r ? Number(r.id) : null;
+    },
+    async lockPool(p, key) {
+      await q.query('SELECT pg_advisory_xact_lock(hashtext($1))', [`market-watch-pool:${p}:${key}`]);
+    },
+    async findPooled(p, key) {
+      const { rows: [r] } = await q.query(FIND_POOLED_SQL, [p, key]);
+      return r ? Number(r.id) : null;
+    },
+    async insertProposal(x) {
+      const { rows: [r] } = await q.query(INSERT_PROPOSAL_SQL, [x.project, x.kind, x.ruleVersionId, x.answerId, JSON.stringify(x.payload), x.reason, x.proposedBy]);
+      return Number(r.id);
+    },
+  };
+}
+
+// createAskStore(pool) — the SQL behind the flow. Every read and write takes the project,
+// and an answer's insert proves its ask is that project's in the statement itself.
+function createAskStore(pool) {
+  const db = require('./db');
+  return {
+    async asksForWeek(project, weekOf) {
+      const { rows } = await pool.query(ASKS_SQL, [project, weekOf]);
+      return rows.map((r) => ({ ...r, id: Number(r.id) }));
+    },
+    async insertAsk(project, a) {
+      const { rows } = await pool.query(INSERT_ASK_SQL, [project, a.weekOf, a.questionKey, a.prompt, JSON.stringify(a.options || []), a.closesAt]);
+      return rows.length > 0;
+    },
+    async chipSource(project) {
+      const { rows } = await pool.query(CHIP_SOURCE_SQL, [project]);
+      return rows;
+    },
+    async answeredWeek(project, weekOf, builderId) {
+      const { rows: [r] } = await pool.query(ANSWERED_SQL, [project, weekOf, builderId]);
+      return r.answered === true;
+    },
+    streak: (project, builderId, now) => db.askStreak(pool, { project, builderId, now }),
+    async teamProposals(project, weekOf, limit = 5) {
+      const { rows } = await pool.query(TEAM_SQL, [project, weekOf, limit]);
+      return rows;
+    },
+    async activeRuleVersionId(project) {
+      const { rows: [r] } = await pool.query(ACTIVE_RULES_SQL, [project]);
+      return r ? Number(r.id) : null;
+    },
+    async tx(fn) {
+      const client = await pool.connect();
+      try {
+        await client.query('BEGIN');
+        const out = await fn(queriesOn(client));
+        await client.query('COMMIT');
+        return out;
+      } catch (e) {
+        await client.query('ROLLBACK').catch(() => {});
+        throw e;
+      } finally {
+        client.release();
+      }
+    },
+  };
+}
+
+module.exports = {
+  // the flow
+  issueWeeklyAsk, cardFor, answer, createAskStore,
+  // pure
+  weekStart, isoWeek, cleanText, normalise, chipOptions, parseAnswer,
+};

package/modules/market-watch/migrations/market_watch_003_ask_pool.sql

@@ -0,0 +1,21 @@
+-- market_watch_003_ask_pool.sql - the weekly ask's pool lookup (task 1004940, goal 1000137).
+--
+-- Each answer to the weekly ask looks for the proposal its pool already holds
+-- (modules/market-watch/ask.js FIND_POOLED_SQL: project + payload->>'pool_key', origin
+-- 'weekly_ask'). Without this index that lookup scans every proposal the project has, once
+-- per answer, inside the answer's transaction. The partial index covers exactly the rows the
+-- lookup can match, whatever their status.
+--
+-- The agree count (TEAM_SQL) needs no new index: it walks the project's asks by
+-- UNIQUE (project, week_of, question_key) and their answers by UNIQUE (ask_id, builder_id,
+-- choice).
+--
+-- Additive and idempotent, like 001 and 002.
+
+BEGIN;
+
+CREATE INDEX IF NOT EXISTS market_watch_proposals_ask_pool
+  ON market_watch_proposals (project, (payload->>'pool_key'))
+  WHERE origin = 'weekly_ask';
+
+COMMIT;

package/modules/market-watch/module.json

@@ -1,8 +1,8 @@
 {
   "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) and its weekly run (an hourly poller that researches each tracked item on the project's own Anthropic key, under the monthly cap) are in; the pages and weekly ask are not yet, so it mounts no routes. 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.2.0",
+  "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) and its weekly run (an hourly poller that researches each tracked item on the project's own Anthropic key, under the monthly cap) are in, and so is the weekly ask card in the hall's attention inbox (task 1004940); the pages are not yet. 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.3.0",
   "coreVersion": "^1.19.0",
   "category": {
     "parent": "knowledge"
@@ -13,9 +13,16 @@
   },
   "contributes": {
     "migrations": true,
+    "routes": [
+      "ask"
+    ],
     "pollers": [
       "hub-seed",
-      "weekly-run"
+      "weekly-run",
+      "weekly-ask"
+    ],
+    "uiSections": [
+      "weekly-ask"
     ]
   },
   "spend": {

package/modules/market-watch/pollers/weekly-ask.js

@@ -0,0 +1,89 @@
+'use strict';
+
+// modules/market-watch/pollers/weekly-ask.js — put out the week's ask card (task 1004940,
+// the ADR 0394 §2 poller shape).
+//
+// The same shape as weekly-run.js, not an import of it: one unref'd HOURLY tick, the first a
+// few minutes after boot plus jitter, kill-switched by ROUTINE_TIMERS_DISABLED=1, and it never
+// throws into the server.
+//
+// BY THE WALL CLOCK, IDEMPOTENT PER PROJECT PER WEEK. The ask belongs to the calendar week
+// (Monday 00:00 UTC, ask.js weekStart), not to the boot: the first tick of a new week creates
+// that week's two question rows, and every later tick that week finds them and does nothing.
+// The UNIQUE (project, week_of, question_key) constraint is what makes it once even with two
+// processes on one database. A deploy restarts this timer and changes nothing.
+//
+// It sends nothing. A member sees the card in the hall's "Needs your attention" card while
+// the week is open and they have not answered; when the week closes it is gone. No reminder,
+// no second ask (the owner's "never nag").
+
+const api = require('../../../src/module-api');
+const ask = require('../ask');
+const { projectKey } = require('../seed');
+
+const log = api.logger('market-watch');
+
+const TICK_MS = Number(process.env.MARKET_WATCH_ASK_TICK_MS) || 60 * 60_000;
+// After hub-seed's 2 minutes, so the hub's first card is drawn from its seeded items.
+const FIRST_MS = Number(process.env.MARKET_WATCH_ASK_FIRST_MS) || 5 * 60_000;
+const JITTER_MS = 60_000;
+
+function defaultProject() {
+  try { return projectKey(api.branding().domains.publicOrigin); } catch { return null; }
+}
+
+let running = false;
+let warnedUnreachable = false;
+
+// tick(deps) — issue this week's ask if it is not out yet. NEVER throws.
+async function tick(deps = {}) {
+  if (running) return { skipped: 'busy' };
+  running = true;
+  try {
+    const project = deps.project !== undefined ? deps.project : defaultProject();
+    if (!project) return { skipped: 'no_project_origin' };
+    const store = deps.store || ask.createAskStore(deps.pool || api.pool);
+    const r = await ask.issueWeeklyAsk(store, { project, now: deps.now ? deps.now() : new Date() });
+    if (r.created) log.info(`[weekly-ask] ${project}: week of ${r.weekOf} asked (${r.created} questions)`);
+    return r;
+  } catch (e) {
+    const msg = (e && e.message) || String(e);
+    if (/ECONNREFUSED|ENOTFOUND|does not exist|connect/i.test(msg)) {
+      if (!warnedUnreachable) { warnedUnreachable = true; log.info(`[weekly-ask] skipped — database unreachable (${msg})`); }
+      return { skipped: 'db_unreachable' };
+    }
+    log.error(`[weekly-ask] tick failed: ${msg}`);
+    if (typeof deps.reportError === 'function') deps.reportError();
+    return { skipped: 'error', error: msg };
+  } finally {
+    running = false;
+  }
+}
+
+let firstTimer = null;
+let interval = null;
+
+// Only reportError is taken from the loader's deps, so a loader dep is never read as a seam.
+function start({ reportError } = {}) {
+  if (process.env.ROUTINE_TIMERS_DISABLED === '1') {
+    log.info('[weekly-ask] disabled (ROUTINE_TIMERS_DISABLED=1)');
+    return;
+  }
+  if (firstTimer || interval) return;
+  const fire = () => tick({ reportError });
+  firstTimer = setTimeout(() => {
+    firstTimer = null;
+    fire();
+    interval = setInterval(fire, TICK_MS);
+    if (interval.unref) interval.unref();
+  }, FIRST_MS + Math.floor(Math.random() * JITTER_MS));
+  if (firstTimer.unref) firstTimer.unref();
+}
+
+function stop() {
+  if (firstTimer) clearTimeout(firstTimer);
+  if (interval) clearInterval(interval);
+  firstTimer = interval = null;
+}
+
+module.exports = { start, stop, tick, TICK_MS };