@bongos/core 1.24.14 → 1.24.16

package/tests/hub_account_page.mjs

@@ -85,9 +85,10 @@ test('the door returns here, and the page calls only its own-scoped routes', ()
   assert.match(PAGE, /href="\/api\/bongos\/auth\/web\/start\?return=\/account&repos=1"/, 'sign-in lands back on /account, asking for repo access once (task 1004549)');
   const calls = [...SCRIPT.matchAll(/request\('(GET|PATCH|POST|DELETE)', '([^']+)'/g)].map((m) => `${m[1]} ${m[2]}`);
   assert.deepEqual([...new Set(calls)].sort(), ['GET /me/cross-project', 'PATCH /me/cross-project', 'PATCH /me/handle', 'PATCH /me/profile', 'GET /my-projects', 'POST /my-projects/', 'GET /me/guilds', 'GET /me/sign-in-methods', 'DELETE /me/sign-in-methods/'].sort());
-  // the bar's two calls live in the shared asset: the identity read and sign out
+  // the bar's calls live in the shared asset: the identity read, sign out, and the
+  // ways in the Link GitHub chip asks (task 1004996)
   const barCalls = [...BAR.matchAll(/fetch\(API \+ '([^']+)', \{ method: '(GET|POST)'/g)].map((m) => `${m[2]} ${m[1]}`);
-  assert.deepEqual(barCalls.sort(), ['GET /me', 'POST /auth/logout']);
+  assert.deepEqual(barCalls.sort(), ['GET /me', 'GET /me/sign-in-methods', 'POST /auth/logout']);
   assert.match(BAR, /var API = '\/api\/bongos';/);
 });
 

package/tests/landing_legal_pages.mjs

@@ -239,10 +239,11 @@ test('cosmos.css still carries the bar and the bands the doors lean on', () => {
   for (const rule of ['.bar{', '.barMark{', '.trig{', '.signinDoor{', '.menuBand{']) assert.ok(css.includes(rule), `cosmos.css still carries ${rule}`);
 });
 
-test('assets/hub-bar.js builds no markup from strings and makes only the bar’s two calls', () => {
+test('assets/hub-bar.js builds no markup from strings and makes only the bar’s three calls', () => {
   assert.doesNotMatch(BAR, /innerHTML|insertAdjacentHTML|outerHTML/);
   const calls = [...BAR.matchAll(/fetch\(API \+ '([^']+)', \{ method: '(GET|POST)'/g)].map((m) => `${m[2]} ${m[1]}`);
-  assert.deepEqual(calls.sort(), ['GET /me', 'POST /auth/logout']);
+  // the identity read, sign out, and the ways in the Link GitHub chip asks (task 1004996)
+  assert.deepEqual(calls.sort(), ['GET /me', 'GET /me/sign-in-methods', 'POST /auth/logout']);
   assert.doesNotMatch(BAR, /gtag|plausible|googletagmanager/, 'the privacy page promises no trackers');
 });
 

package/tests/market_watch_data_db.mjs

@@ -29,6 +29,7 @@ const db = require('../modules/market-watch/db.js');
 const MIGRATION = readFileSync(new URL('../modules/market-watch/migrations/market_watch_001_tables.sql', import.meta.url), 'utf8');
 const MIGRATION_002 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_002_run.sql', import.meta.url), 'utf8');
 const MIGRATION_003 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_003_ask_pool.sql', import.meta.url), 'utf8');
+const MIGRATION_004 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_004_entry_corrections.sql', import.meta.url), 'utf8');
 const run = require('../modules/market-watch/run.js');
 const store = require('../modules/market-watch/store.js');
 const settings = require('../modules/market-watch/settings.js');
@@ -86,6 +87,11 @@ try {
     // market_watch_003 (task 1004940): the weekly ask's pool-lookup index.
     await q(MIGRATION_003);
     await q(MIGRATION_003);
+    // market_watch_004 (task 1005016): the applied-correction lookup index.
+    await q(MIGRATION_004);
+    await q(MIGRATION_004);
+    const { rows: [ix] } = await q(`SELECT count(*)::int AS n FROM pg_indexes WHERE indexname = 'market_watch_proposals_entry_corrections'`);
+    assert.equal(ix.n, 1, 'the correction lookup index exists');
     const { rows } = await q(`SELECT count(*)::int AS n FROM information_schema.tables WHERE table_name LIKE 'market\\_watch\\_%'`);
     assert.ok(rows[0].n >= 10, `tables: ${rows[0].n}`);
   });

package/tests/market_watch_pages.mjs

@@ -134,7 +134,10 @@ test('each of the four changes, with a one-line reason, becomes a proposal the s
     'the direction comes from the item, never from the client');
   assert.deepEqual(norm({ kind: 'move_kind', reason: 'r' }, { id: 9, kind: 'partner' }).value.payload, { from: 'partner', to: 'competitor' });
   assert.deepEqual(norm({ kind: 'add_source', url: 'https://example.org/changelog', reason: 'r' }).value.payload, { source_url: 'https://example.org/changelog' });
-  assert.deepEqual(norm({ kind: 'correct_entry', log_entry_id: '15', reason: 'r' }).value, { kind: 'correct_entry', item_id: 4, log_entry_id: 15, reason: 'r', payload: {} });
+  // task 1005016: the proposal carries the correction itself, or a wrong flag
+  assert.deepEqual(norm({ kind: 'correct_entry', log_entry_id: '15', takeaway: ' Raised a seed,\n not a Series B. ', reason: 'r' }).value,
+    { kind: 'correct_entry', item_id: 4, log_entry_id: 15, reason: 'r', payload: { takeaway: 'Raised a seed, not a Series B.', summary: 'Correct an entry to read "Raised a seed, not a Series B."' } });
+  assert.deepEqual(norm({ kind: 'correct_entry', log_entry_id: 15, wrong: true, reason: 'r' }).value.payload, { wrong: true, summary: 'Mark an entry as wrong' });
   assert.deepEqual(norm({ kind: 'remove_item', reason: 'shut down' }).value.payload, {}, 'stop tracking');
   assert.deepEqual(pages.normalizeProposal({ kind: 'add_item', scout: 'topic', name: ' agent pay models ', reason: 'r' }).value.payload,
     { kind: 'topic', name: 'agent pay models', url: null });
@@ -151,7 +154,11 @@ test('a proposal is refused without a reason, with a bad value, or about somethi
   assert.equal(err({ kind: 'rescore', dimension: 'human_gates', value: '', reason: 'r' }), 'invalid_value');
   assert.equal(err({ kind: 'move_kind', reason: 'r' }, { id: 3, kind: 'topic' }), 'cannot_move_topic');
   assert.equal(err({ kind: 'add_source', url: 'javascript:alert(1)', reason: 'r' }), 'invalid_url');
-  assert.equal(err({ kind: 'correct_entry', log_entry_id: '0', reason: 'r' }), 'invalid_entry');
+  assert.equal(err({ kind: 'correct_entry', log_entry_id: '0', takeaway: 'x', reason: 'r' }), 'invalid_entry');
+  assert.equal(err({ kind: 'correct_entry', log_entry_id: '15', reason: 'r' }), 'correction_required', 'the reason alone is no correction');
+  assert.equal(err({ kind: 'correct_entry', log_entry_id: '15', takeaway: '  ', reason: 'r' }), 'correction_required');
+  assert.equal(err({ kind: 'correct_entry', log_entry_id: '15', takeaway: 'x', wrong: true, reason: 'r' }), 'invalid_correction', 'not both');
+  assert.equal(err({ kind: 'correct_entry', log_entry_id: '15', takeaway: 'x'.repeat(501), reason: 'r' }), 'correction_too_long');
   assert.equal(err({ kind: 'rule_change', reason: 'r' }), 'invalid_kind', 'a rules change is the rules page\'s, not this one\'s');
   assert.equal(pages.normalizeProposal({ kind: 'rescore', reason: 'r' }).error, 'item_not_found');
   assert.equal(pages.normalizeProposal({ kind: 'add_item', scout: 'friend', name: 'x', reason: 'r' }).error, 'invalid_scout');
@@ -166,10 +173,79 @@ test('the propose dialog offers exactly the four changes, and posts what the ser
   assert.deepEqual(MW.bodyFor('change', form({ kind: 'rescore', dimension: 'human_gates', value: '8', reason: ' r ' }), { id: 4 }),
     { kind: 'rescore', item_id: 4, reason: 'r', dimension: 'human_gates', value: '8' });
   assert.deepEqual(MW.bodyFor('stop', form({ reason: 'gone' }), { id: 4 }), { kind: 'remove_item', item_id: 4, reason: 'gone' });
+  // correct_entry (task 1005016): the corrected words, or the wrong flag instead
+  assert.match(html, /name="takeaway"/);
+  assert.match(html, /name="wrong" type="checkbox"/);
+  const fix = form({ kind: 'correct_entry', log_entry_id: '15', takeaway: ' seed ', reason: 'r' });
+  fix.elements.wrong = { value: 'true', checked: false };
+  assert.deepEqual(MW.bodyFor('change', fix, { id: 4 }), { kind: 'correct_entry', item_id: 4, reason: 'r', log_entry_id: '15', takeaway: 'seed' });
+  fix.elements.wrong.checked = true;
+  assert.deepEqual(MW.bodyFor('change', fix, { id: 4 }), { kind: 'correct_entry', item_id: 4, reason: 'r', log_entry_id: '15', wrong: true });
+  for (const b of [MW.bodyFor('change', fix, { id: 4 }), { ...MW.bodyFor('change', fix, { id: 4 }), wrong: undefined, takeaway: 'seed' }]) {
+    assert.equal(pages.normalizeProposal(b, { item: COP }).ok, true, 'the dialog posts what the server reads');
+  }
+});
+
+test('a corrected entry reads corrected on the item page; one marked wrong is no report on the home', () => {
+  const it = byName('GitHub Copilot', 'competitor');
+  const cf = rows.caseFileFrom(R, RUNS, it.id);
+  cf[0] = { ...cf[0], corrected_at: new Date('2026-10-30T10:00:00Z'), correction_reason: '<b>their post</b>', marked_wrong: false };
+  cf[1] = { ...cf[1], corrected_at: new Date('2026-10-30T11:00:00Z'), correction_reason: 'still running', marked_wrong: true };
+  const v = pages.shapeItem({ item: it, entries: cf, history: { series: {}, runs: [] }, rules: RULES });
+  assert.deepEqual(v.entries[0].corrected, { on: '2026-10-30', reason: '<b>their post</b>', wrong: false });
+  assert.deepEqual(v.entries[1].corrected, { on: '2026-10-30', reason: 'still running', wrong: true });
+  assert.equal(v.entries[2].corrected, null, 'an entry nobody corrected carries no note');
+  // the read behind it: the latest APPLIED correct_entry of this project, per entry
+  const caseSql = readFileSync(new URL('../modules/market-watch/db.js', import.meta.url), 'utf8');
+  assert.match(caseSql, /p\.project = i\.project AND p\.log_entry_id = e\.id AND p\.kind = 'correct_entry' AND p\.status = 'applied'/);
+  const pagesSrc = readFileSync(new URL('../modules/market-watch/pages.js', import.meta.url), 'utf8');
+  assert.match(pagesSrc, /AND NOT COALESCE\(\(SELECT p\.payload->>'wrong' = 'true' FROM market_watch_proposals p/, 'the home skips an entry marked wrong');
+  // both lookups are served by market_watch_004's partial index, in the order they read
+  const m4 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_004_entry_corrections.sql', import.meta.url), 'utf8');
+  assert.match(m4, /CREATE INDEX IF NOT EXISTS market_watch_proposals_entry_corrections\s+ON market_watch_proposals \(log_entry_id, decided_at DESC, id DESC\)\s+WHERE kind = 'correct_entry' AND status = 'applied';/);
+  assert.match(m4, /^[\s\S]*BEGIN;[\s\S]*COMMIT;\s*$/, 'transactional');
+  assert.ok(/^[\x00-\x7F]*$/.test(m4), 'ASCII only');
+  for (const src of [caseSql, pagesSrc]) assert.match(src, /ORDER BY p\.decided_at DESC, p\.id DESC/);
 });
 
 // ---- untrusted text becomes markup only through esc --------------------------------
 
+// task 1005018: the dialog's screen-reader name follows the action that opened it.
+test('the propose dialog is named by its own title: propose a change, stop tracking or send a new scout', () => {
+  const titleOf = (html) => {
+    const all = [...html.matchAll(/<span[^>]*id="mw-propose-title"[^>]*>([^<]*)<\/span>/g)];
+    assert.equal(all.length, 1, 'exactly one title to point at');
+    return all[0][1];
+  };
+  const item = { id: 4, kind: 'competitor', name: 'Copilot' };
+  const expected = { change: 'propose a change', stop: 'stop tracking', scout: 'send a new scout' };
+  for (const [mode, words] of Object.entries(expected)) {
+    // a fake <dialog> that starts with the old fixed label, as a page served before this fix did
+    const attrs = new Map([['aria-label', 'Propose a change']]);
+    const stub = () => ({ value: '', checked: false, hidden: false, addEventListener() {}, focus() {} });
+    const fields = new Proxy({}, { get: (o, k) => (o[k] = o[k] || stub()) });
+    const form = { elements: fields, addEventListener() {}, querySelector: () => stub() };
+    let html = '';
+    const dlg = {
+      set innerHTML(v) { html = v; }, get innerHTML() { return html; },
+      setAttribute: (k, v) => attrs.set(k, String(v)), removeAttribute: (k) => attrs.delete(k), getAttribute: (k) => attrs.get(k) ?? null,
+      querySelector: (s) => (s === 'form' ? form : stub()), querySelectorAll: () => [], showModal() {}, close() {},
+    };
+    const saved = globalThis.document;
+    globalThis.document = { getElementById: (id) => (id === 'mw-propose' ? dlg : null) };
+    try { MW.openPropose(mode, { item, dimensions: [], entries: [] }, () => {}); } finally { globalThis.document = saved; }
+    assert.equal(attrs.has('aria-label'), false, `${mode}: no fixed label left to override the title`);
+    assert.equal(attrs.get('aria-labelledby'), 'mw-propose-title', mode);
+    assert.equal(titleOf(html), words, `${mode}: the name a screen reader hears`);
+  }
+  for (const page of ['market-watch.html', 'market-watch-item.html']) {
+    const src = readFileSync(new URL(`../modules/hall-ui/public/${page}`, import.meta.url), 'utf8');
+    const tag = src.match(/<dialog[^>]*id="mw-propose"[^>]*>/)[0];
+    assert.doesNotMatch(tag, /aria-label=/, `${page}: no fixed name on the dialog`);
+    assert.match(tag, /aria-labelledby="mw-propose-title"/, page);
+  }
+});
+
 test('an item name or takeaway with markup in it is escaped on the landscape and in the dialog', () => {
   const evil = '<img src=x onerror=alert(1)>"\'';
   const h = home();
@@ -307,6 +383,15 @@ test('a member files a proposal: one row, origin member, their id, this project;
   assert.equal((await call('POST', '/market-watch/proposals', { kind: 'remove_item', item_id: 4, reason: 'r', status: 'approved' })).status, 400,
     'an unknown field (a member trying to approve their own proposal) is refused');
   assert.equal(inserts.length, 2, 'refused proposals write nothing');
+  // task 1005016: the route takes the correction (or the wrong flag) and stores it on the row
+  const fix = await call('POST', '/market-watch/proposals', { kind: 'correct_entry', item_id: 4, log_entry_id: 15, takeaway: 'Raised a seed.', reason: 'their post' });
+  assert.equal(fix.status, 201);
+  assert.deepEqual([inserts[2].params[3], JSON.parse(inserts[2].params[4]).takeaway], [15, 'Raised a seed.']);
+  const wrong = await call('POST', '/market-watch/proposals', { kind: 'correct_entry', item_id: 4, log_entry_id: 15, wrong: true, reason: 'still running' });
+  assert.equal(wrong.status, 201);
+  assert.equal(JSON.parse(inserts[3].params[4]).wrong, true);
+  assert.equal((await call('POST', '/market-watch/proposals', { kind: 'correct_entry', item_id: 4, log_entry_id: 15, reason: 'r' })).status, 400, 'no correction, no proposal');
+  assert.equal(inserts.length, 4);
 });
 
 // ---- the quiet off state -----------------------------------------------------------

package/tests/market_watch_rules.mjs

@@ -45,7 +45,7 @@ const V1 = {
 
 // ── the in-memory database ─────────────────────────────────────────────────────
 function makeDb() {
-  const t = { versions: [], proposals: [], items: [], scores: [], runs: [{ id: 50, project: P, status: 'done' }], seq: 100 };
+  const t = { versions: [], proposals: [], items: [], scores: [], entries: [], runs: [{ id: 50, project: P, status: 'done' }], seq: 100 };
   const nextId = () => ++t.seq;
   t.versions.push({ id: nextId(), project: P, ...JSON.parse(JSON.stringify(V1)), approved_at: new Date('2026-10-28'), created_at: new Date('2026-10-28') });
   t.items.push({ id: nextId(), project: P, kind: 'competitor', name: 'OpenHands', url: 'https://openhands.dev', status: 'active', why_tracked: '' });
@@ -76,7 +76,11 @@ function makeDb() {
       case 'mw:proposal-lock':
       case 'mw:proposal-get-open': {
         const p = prop(a, b);
-        return one(p && (tag === 'mw:proposal-lock' || p.status === 'open') ? p : null);
+        if (!p || !(tag === 'mw:proposal-lock' || p.status === 'open')) return one(null);
+        // Hand back only the columns the real SELECT names (task 1005026): returning the
+        // whole row hid a lock that never read log_entry_id, so every correction failed.
+        const cols = String(sql).match(/SELECT\s+([\s\S]+?)\s+FROM/)[1].split(',').map((x) => x.trim());
+        return one(Object.fromEntries(cols.map((k) => [k, p[k]])));
       }
       case 'mw:rules-max-version':
         return one({ v: Math.max(0, ...t.versions.filter((v) => v.project === a).map((v) => v.version)) });
@@ -131,6 +135,18 @@ function makeDb() {
         Object.assign(p, { status: c, decided_by: d, decided_at: new Date(), rule_version_id: e ?? p.rule_version_id, item_id: f ?? p.item_id, payload: { ...p.payload, ...JSON.parse(g) } });
         return one(p);
       }
+      case 'mw:entry-lock': {
+        // the entry, only through an item of this project, and only the proposal's item
+        const e = t.entries.find((x) => String(x.id) === String(a) && String(x.item_id) === String(c));
+        const it = e && t.items.find((x) => x.id === e.item_id && x.project === b);
+        return one(e && it ? { ...e } : null);
+      }
+      case 'mw:entry-correct': {
+        const e = t.entries.find((x) => String(x.id) === String(a));
+        if (!e || t.entries.some((o) => o.id !== e.id && o.item_id === e.item_id && o.run_id === e.run_id && o.takeaway === b)) return one(null);
+        e.takeaway = b;
+        return one({ id: e.id });
+      }
       case 'mw:proposal-at-vote': {
         const p = prop(a, b);
         if (p && p.status === 'open') p.payload = { ...p.payload, matter_id: c };
@@ -282,15 +298,71 @@ test('an approved add-item proposal creates the tracked item; the run\'s and the
   assert.equal(proposals.itemFromPayload({}), null);
 });
 
-test('remove_item takes the item off the watch; a correct_entry is recorded as approved, not applied', async () => {
+test('remove_item takes the item off the watch', async () => {
   const { t, pool, withTx } = makeDb();
   const itemId = t.items[0].id;
   const filed = await proposals.createProposal(pool, { project: P, step: 'names', change: { op: 'remove', item_id: itemId }, reason: 'not a rival', proposedBy: ADA });
   await proposals.decideProposal({ project: P, id: filed.proposal.id, decision: 'approve', decidedBy: OWNER, withTx });
   assert.equal(t.items[0].status, 'removed');
-  t.proposals.push({ id: 900, project: P, kind: 'correct_entry', origin: 'member', item_id: itemId, log_entry_id: 7, payload: {}, status: 'open', proposed_by: ADA });
+});
+
+// task 1005016: an approved correct_entry corrects the entry it names.
+function withEntries() {
+  const d = makeDb();
+  const itemId = d.t.items[0].id;
+  d.t.items.push({ id: 300, project: P, kind: 'competitor', name: 'Other', url: 'https://other.dev', status: 'active' });
+  d.t.items.push({ id: 400, project: 'https://other.example', kind: 'competitor', name: 'Theirs', url: 'https://theirs.dev', status: 'active' });
+  d.t.entries.push(
+    { id: 7, item_id: itemId, run_id: 50, takeaway: 'OpenHands raised a Series B.' },
+    { id: 8, item_id: itemId, run_id: 50, takeaway: 'OpenHands shut down.' },
+    { id: 9, item_id: 300, run_id: 50, takeaway: 'Another item\'s entry.' },
+    { id: 10, item_id: 400, run_id: 50, takeaway: 'Another project\'s entry.' },
+  );
+  const file = (id, payload, { item = itemId, entry = 7 } = {}) => d.t.proposals.push({
+    id, project: P, kind: 'correct_entry', origin: 'member', item_id: item, log_entry_id: entry, payload, reason: 'their post says seed', status: 'open', proposed_by: ADA,
+  });
+  return { ...d, itemId, file };
+}
+
+test('CORRECT AN ENTRY: approving rewrites the entry, and keeps who, when, why and the old text', async () => {
+  const { t, withTx, file } = withEntries();
+  file(900, { takeaway: 'OpenHands raised a seed round, not a Series B.' });
   const out = await proposals.decideProposal({ project: P, id: 900, decision: 'approve', decidedBy: OWNER, withTx });
-  assert.deepEqual([out.status, out.applied], ['approved', false]);
+  assert.deepEqual([out.ok, out.status, out.applied, out.log_entry_id], [true, 'applied', true, 7]);
+  assert.equal(t.entries.find((e) => e.id === 7).takeaway, 'OpenHands raised a seed round, not a Series B.', 'the entry itself now reads corrected');
+  const p = t.proposals.find((x) => x.id === 900);
+  assert.equal(p.status, 'applied');
+  assert.equal(p.proposed_by, ADA, 'who proposed it');
+  assert.equal(p.decided_by, OWNER, 'who approved it');
+  assert.ok(p.decided_at instanceof Date, 'when');
+  assert.equal(p.reason, 'their post says seed', 'why');
+  assert.equal(p.payload.was, 'OpenHands raised a Series B.', 'the text it replaced is never lost');
+});
+
+test('CORRECT AN ENTRY: a wrong flag leaves the text as found and applies the flag', async () => {
+  const { t, withTx, file } = withEntries();
+  file(901, { wrong: true }, { entry: 8 });
+  const out = await proposals.decideProposal({ project: P, id: 901, decision: 'approve', decidedBy: OWNER, withTx });
+  assert.deepEqual([out.status, out.applied], ['applied', true]);
+  assert.equal(t.entries.find((e) => e.id === 8).takeaway, 'OpenHands shut down.');
+  assert.deepEqual([t.proposals.find((x) => x.id === 901).payload.wrong, t.proposals.find((x) => x.id === 901).payload.was], [true, 'OpenHands shut down.']);
+});
+
+test('CORRECT AN ENTRY: refused, and left open, when it names nothing it may change', async () => {
+  const { t, withTx, file } = withEntries();
+  const decide = (id) => proposals.decideProposal({ project: P, id, decision: 'approve', decidedBy: OWNER, withTx });
+  file(902, {}); // filed before task 1005016: the reason was the correction
+  assert.equal((await decide(902)).reason, 'no_correction');
+  file(903, { takeaway: 'x' }, { entry: 9 }); // another item's entry
+  assert.equal((await decide(903)).reason, 'entry_gone');
+  file(904, { takeaway: 'x' }, { item: 400, entry: 10 }); // another project's item and entry
+  assert.equal((await decide(904)).reason, 'entry_gone');
+  file(905, { takeaway: 'OpenHands shut down.' }); // would duplicate entry 8 in the same run
+  assert.equal((await decide(905)).reason, 'same_as_another_entry');
+  for (const id of [902, 903, 904, 905]) assert.equal(t.proposals.find((x) => x.id === id).status, 'open', `proposal ${id} stays open`);
+  assert.deepEqual(t.entries.map((e) => e.takeaway), ['OpenHands raised a Series B.', 'OpenHands shut down.', 'Another item\'s entry.', 'Another project\'s entry.'], 'no entry changed');
+  // a decline of the old kind still works
+  assert.equal((await proposals.decideProposal({ project: P, id: 902, decision: 'decline', decidedBy: OWNER, withTx })).status, 'rejected');
 });
 
 test('a project cannot decide another project\'s proposal', async () => {
@@ -422,6 +494,24 @@ test('OWNER ONLY: a member who is not the owner gets 403 and nothing changes; th
   assert.equal((await call(OWNER, 'POST', `/market-watch/proposals/${id}/decide`, { decision: 'maybe' })).status, 400);
 });
 
+test('OWNER ONLY, correcting an entry: a member gets 403 and the entry is untouched; the owner\'s approval corrects it', async () => {
+  const itemId = RT.t.items[0].id;
+  RT.t.entries.push({ id: 70, item_id: itemId, run_id: 50, takeaway: 'Old words.' });
+  RT.t.proposals.push({ id: 970, project: P, kind: 'correct_entry', origin: 'member', item_id: itemId, log_entry_id: 70, payload: { takeaway: 'New words.' }, reason: 'r', status: 'open', proposed_by: ADA });
+  const denied = await call(ADA, 'POST', '/market-watch/proposals/970/decide', { decision: 'approve' });
+  assert.deepEqual([denied.status, denied.code], [403, 'owner_only']);
+  assert.equal(RT.t.entries.find((e) => e.id === 70).takeaway, 'Old words.');
+  assert.equal(RT.t.proposals.find((p) => p.id === 970).status, 'open');
+  assert.equal((await call(null, 'POST', '/market-watch/proposals/970/decide', { decision: 'approve' })).status, 401);
+  const ok = await call(OWNER, 'POST', '/market-watch/proposals/970/decide', { decision: 'approve' });
+  assert.equal(ok.status, 200, JSON.stringify(ok.json));
+  assert.equal(RT.t.entries.find((e) => e.id === 70).takeaway, 'New words.');
+  RT.t.proposals.push({ id: 971, project: P, kind: 'correct_entry', origin: 'member', item_id: itemId, log_entry_id: 70, payload: {}, reason: 'r', status: 'open', proposed_by: ADA });
+  const old = await call(OWNER, 'POST', '/market-watch/proposals/971/decide', { decision: 'approve' });
+  assert.deepEqual([old.status, old.code], [409, 'no_correction'], 'an old proposal with no correction says so in words');
+  assert.match(old.json.error.message, /does not say how the entry should read/);
+});
+
 test('a government that hands Rules to a sitting: the owner cannot decide alone (409), the page offers the vote', async () => {
   const filed = await proposals.createProposal(RT.pool, { project: P, step: 'brief', change: { op: 'set', text: 'Five lines.' }, reason: 'r', proposedBy: ADA });
   const sitting = {
@@ -553,4 +643,10 @@ test('the payloads the item page files are the ones an approval applies', () =>
     assert.ok(n.ok, body.kind);
     assert.ok(proposals.itemChange(n.value.kind, n.value.payload), `${body.kind}: pages.js writes a payload proposals.js applies`);
   }
+  // correct_entry (task 1005016): both shapes the item page files are ones an approval applies
+  const fix = pages.normalizeProposal({ kind: 'correct_entry', log_entry_id: '7', takeaway: ' seed,\nnot B ', reason: 'r' }, { item });
+  assert.deepEqual(proposals.entryCorrection(fix.value.payload), { takeaway: 'seed, not B' });
+  const wrong = pages.normalizeProposal({ kind: 'correct_entry', log_entry_id: '7', wrong: true, reason: 'r' }, { item });
+  assert.deepEqual(proposals.entryCorrection(wrong.value.payload), { wrong: true, takeaway: null });
+  assert.equal(proposals.entryCorrection({}), null);
 });

package/tests/market_watch_rules_db.mjs

@@ -27,11 +27,14 @@ const seed = require('../modules/market-watch/seed.js');
 const store = require('../modules/market-watch/store.js');
 const proposals = require('../modules/market-watch/proposals.js');
 const view = require('../modules/market-watch/rules-view.js');
+const pages = require('../modules/market-watch/pages.js');
+const db = require('../modules/market-watch/db.js');
 const research = require('../modules/market-watch/research.js');
 const pricing = require('../src/bongos/llm-pricing.js');
 
 const MIGRATION = readFileSync(new URL('../modules/market-watch/migrations/market_watch_001_tables.sql', import.meta.url), 'utf8');
 const MIGRATION_002 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_002_run.sql', import.meta.url), 'utf8');
+const MIGRATION_004 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_004_entry_corrections.sql', import.meta.url), 'utf8');
 
 const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
 try {
@@ -60,6 +63,8 @@ const withTx = async (fn) => {
 
 async function cleanup() {
   await q(`DELETE FROM market_watch_proposals WHERE project = $1`, [P]).catch(() => {});
+  await q(`DELETE FROM market_watch_log_entries WHERE item_id IN (SELECT id FROM market_watch_items WHERE project = $1)`, [P]).catch(() => {});
+  await q(`DELETE FROM market_watch_runs WHERE project = $1`, [P]).catch(() => {});
   await q(`DELETE FROM market_watch_items WHERE project = $1`, [P]).catch(() => {});
   await q(`DELETE FROM market_watch_rule_versions WHERE project = $1`, [P]).catch(() => {});
   await q(`DELETE FROM builders WHERE id = ANY($1::bigint[])`, [[OWNER, ADA]]).catch(() => {});
@@ -73,6 +78,7 @@ async function check(name, fn) {
 try {
   await q(MIGRATION);
   await q(MIGRATION_002);
+  await q(MIGRATION_004);
   await cleanup();
   await insertTestBuilders(pool, [{ id: OWNER, login: 't1004941-owner' }, { id: ADA, login: 't1004941-ada' }]);
   const r = seed.RULES_V1;
@@ -112,6 +118,42 @@ try {
     assert.deepEqual([it.kind, it.url, it.added_via, String(it.added_by), it.status], ['competitor', 'https://algora.io', 'proposal', String(ADA), 'active']);
   });
 
+  // task 1005016: an approved correct_entry rewrites the entry, keeps who/when/why and
+  // the old text on the proposal, and the case file reads the correction; a wrong flag
+  // leaves the text and reads as marked wrong.
+  await check('an approved correct_entry corrects the log entry, and the case file shows it', async () => {
+    const { rows: [it] } = await q(`SELECT id FROM market_watch_items WHERE project = $1 AND name = 'Algora'`, [P]);
+    const { rows: [run] } = await q(`INSERT INTO market_watch_runs (project, status, trigger) VALUES ($1, 'done', 'manual') RETURNING id`, [P]);
+    const { rows: [e1] } = await q(`INSERT INTO market_watch_log_entries (item_id, run_id, type, takeaway, source_url, confidence)
+                                    VALUES ($1, $2, 'news', 'Algora raised a Series B.', 'https://algora.io/blog', 2) RETURNING id`, [it.id, run.id]);
+    const { rows: [e2] } = await q(`INSERT INTO market_watch_log_entries (item_id, run_id, type, takeaway, source_url, confidence)
+                                    VALUES ($1, $2, 'news', 'Algora shut down.', 'https://algora.io/x', 1) RETURNING id`, [it.id, run.id]);
+    const file = async (body) => {
+      const n = pages.normalizeProposal({ kind: 'correct_entry', item_id: it.id, ...body }, { item: { id: Number(it.id), kind: 'competitor' } });
+      assert.equal(n.ok, true, JSON.stringify(n));
+      return pages.insertProposal(pool, { project: P, proposal: n.value, builderId: ADA });
+    };
+    const fix = await file({ log_entry_id: String(e1.id), takeaway: 'Algora raised a seed round, not a Series B.', reason: 'their post says seed' });
+    const out = await proposals.decideProposal({ project: P, id: fix.id, decision: 'approve', decidedBy: OWNER, withTx });
+    assert.deepEqual([out.ok, out.status], [true, 'applied'], JSON.stringify(out));
+    const { rows: [e] } = await q(`SELECT takeaway FROM market_watch_log_entries WHERE id = $1`, [e1.id]);
+    assert.equal(e.takeaway, 'Algora raised a seed round, not a Series B.');
+    const { rows: [p] } = await q(`SELECT status, proposed_by, decided_by, decided_at, reason, payload FROM market_watch_proposals WHERE id = $1`, [fix.id]);
+    assert.deepEqual([p.status, String(p.proposed_by), String(p.decided_by), p.reason, p.payload.was],
+      ['applied', String(ADA), String(OWNER), 'their post says seed', 'Algora raised a Series B.']);
+    assert.ok(p.decided_at instanceof Date);
+    const wrong = await file({ log_entry_id: String(e2.id), wrong: true, reason: 'they are still running' });
+    assert.equal((await proposals.decideProposal({ project: P, id: wrong.id, decision: 'approve', decidedBy: OWNER, withTx })).status, 'applied');
+    const cf = await db.caseFile(pool, { project: P, itemId: it.id });
+    const byId = new Map(cf.map((x) => [String(x.id), x]));
+    assert.equal(byId.get(String(e1.id)).correction_reason, 'their post says seed');
+    assert.equal(byId.get(String(e1.id)).marked_wrong, false);
+    assert.equal(byId.get(String(e2.id)).marked_wrong, true);
+    assert.equal(byId.get(String(e2.id)).takeaway, 'Algora shut down.', 'a wrong entry keeps its text');
+    const shaped = pages.shapeItem({ item: { id: it.id }, entries: cf, history: {}, rules: null });
+    assert.equal(shaped.entries.find((x) => x.id === Number(e2.id)).corrected.wrong, true);
+  });
+
   await check('the page read runs on the real schema', async () => {
     await proposals.createProposal(pool, { project: P, step: 'brief', change: { op: 'set', text: 'Write five lines.' }, reason: 'shorter', proposedBy: ADA });
     const page = await view.readView(pool, { project: P, decide: { mode: 'owner' }, pricing, model: research.MODEL });

package/tests/nav_permission_atoms.mjs

@@ -94,7 +94,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // "Upgraded to core X" notice after a move; task 1004826: Standing is Accomplishments;
 // task 1004846: the new logo (its bump landed late, in task 1004852); task 1004938: the
 // Market Watch settings nav item and its fuel glyph.
-const SHELL_SHA = 'b89fd877947ae9f8';
+const SHELL_SHA = '1a23b1cf13567eff';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);

package/tests/pay_terms.mjs

@@ -23,6 +23,14 @@ let statements = [];
 const query = async (sql, params = []) => {
   statements.push(sql);
   if (/^\s*(BEGIN|COMMIT|ROLLBACK)/i.test(sql)) return { rows: [] };
+  if (/FROM lifecycle_pay_type_gates/.test(sql)) {
+    // task 1004991: these cases are about the terms, so every gate reads as cleared;
+    // tests/pay_type_gates.mjs is where an open gate refuses.
+    const gates = require('../modules/lifecycle/pay-type-gates.js');
+    const at = new Date(Date.UTC(2026, 9, 30));
+    return { rows: params[0].flatMap((pay_type) => gates.requirementIds(pay_type).map((requirement) => (
+      { pay_type, requirement, state: 'cleared', evidence_ref: 'test', decided_by: 1, decided_at: at }))) };
+  }
   if (/INSERT INTO lifecycle_pay_term_sets/.test(sql)) {
     const row = { id: sets.length + 1, task_id: params[0], set_by: params[1], set_at: new Date(Date.UTC(2026, 9, 30, 0, sets.length)) };
     sets.push(row);