@giamme/forge 0.10.0 → 0.11.1

package/ui/forge_ui/static/findingsview.js

@@ -16,7 +16,7 @@
   const MAX_FPS = 25, MAX_LABELS = 5, MAX_LABEL = 50, MAX_REASON = 500;
   const list = v => Array.isArray(v) ? v : [];
   const SEVERITIES = ['P0', 'P1', 'P2', 'P3'];
-  const ORIGINS = ['tolerated', 'review', 'plausible'];
+  const ORIGINS = ['tolerated', 'accepted', 'review', 'plausible'];
   const STATUSES = ['open', 'filed', 'fixed', 'dismissed'];
 
   /* ---------- pure ---------- */
@@ -64,6 +64,20 @@
     const note = n > MAX_FPS ? `${n} selected: at most ${MAX_FPS} per action` : '';
     return { fps, count: n, enabled: n >= 1 && n <= MAX_FPS, note };
   }
+  // Fingerprints "Select shown open" adds. `rows` are the rows the filters leave shown. The cap is how many of
+  // those are already selected and open — the same rows File and Dismiss take — so a selection a filter hides stays
+  // selected and does not count. A shown row that is not open is not added.
+  function selectShownOpen(rows, selected) {
+    const chosen = new Set(selected instanceof Set || Array.isArray(selected) ? selected : []);
+    const add = [];
+    for (const r of list(rows)) {
+      if (!selectable('file', r) || chosen.has(r.fp)) continue;
+      if (selection('file', rows, chosen).count >= MAX_FPS) break;
+      chosen.add(r.fp);
+      add.push(r.fp);
+    }
+    return add;
+  }
   const bit = v => v ? '1' : '0';
   // The GET path: `o` = { scope, offline, plausible, dismissed, only (fingerprints) }.
   function issuesUrl(key, o) {
@@ -104,8 +118,27 @@
       return { kind: 'note', text: c && c.note ? c.note : 'no detail' };
     });
   }
+  // The CLI's `notes` as lines for the dialog, only when the POST created nothing: a bare "0 created" says no reason, the
+  // notes ("--only fp: no such open finding") do. When something was created the notes are not about the dialog.
+  function emptyNotes(created, notes) {
+    return list(created).some(c => c && c.url) ? [] : list(notes).map(n => String(n)).filter(Boolean);
+  }
   // An untrusted URL becomes a link only when it is a plain https address.
   const safeUrl = u => typeof u === 'string' && /^https:\/\/[^\s"'<>]+$/.test(u) ? u : null;
+  // The marker for a finding whose whole-run review is outdated, or null. The lamp is the hollow unlit
+  // `.st-outdated`. `title` is the same sentence the issue body adds, ids cut after 5, so a row can show it
+  // without building HTML. A current review, and any finding that is not from a whole-run review, has none.
+  function reviewMarker(row) {
+    const review = row && row.review;
+    if (!review || review.outdated !== true) return null;
+    const ids = list(review.merged_since).map(id => String(id));
+    const shown = ids.slice(0, 5), extra = ids.length - shown.length;
+    const names = shown.join(', ') + (extra > 0 ? ', +' + extra + ' more' : '');
+    const n = ids.length;
+    const sentence = `The review is outdated: ${n} ${n === 1 ? 'task' : 'tasks'} merged into the integration branch after it`
+      + (names ? ` (${names})` : '') + ', so check whether they fixed it first.';
+    return { lamp: 'st-outdated', label: 'outdated review', title: sentence, sentence };
+  }
 
   /* ---------- DOM ---------- */
   function render(host, ctx) {
@@ -162,7 +195,7 @@
     const dismissKey = key_('Dismiss', undefined, () => openDismiss());
     const undismissKey = key_('Undismiss', undefined, () => doDismiss(true, ''));
     const allKey = key_('Select shown open', undefined, () => {
-      for (const r of shown()) if (selectable('file', r) && s.selected.size < MAX_FPS) s.selected.add(r.fp);
+      for (const fp of selectShownOpen(shown(), s.selected)) s.selected.add(fp);
       drawTable(); syncActions();
     });
     const noneKey = key_('Clear selection', undefined, () => { s.selected.clear(); drawTable(); syncActions(); });
@@ -179,6 +212,9 @@
     host.append(dlg);
 
     const shown = () => filterRows(s.rows, { ...s.filter, dismissed: s.dismissed });
+    // What an action takes: the selected rows the filters leave visible. Rows hidden by a filter stay in s.selected, so
+    // they come back with the filter, but no button counts them and no action reaches them.
+    const picked = action => selection(action, shown(), s.selected);
     function syncScope() {
       for (const [v, b] of Object.entries(scopeKeys)) b.setAttribute('aria-pressed', String(s.scope === v));
       lede.textContent = s.scope === 'run' ? `Findings this run left unfixed${ctx.run && ctx.run.goal ? ': ' + String(ctx.run.goal).split('\n')[0] : ''}.`
@@ -187,17 +223,27 @@
     function syncActions() {
       actions.hidden = !s.writes;
       if (!s.writes) return;
-      const f = selection('file', s.rows, s.selected), d = selection('dismiss', s.rows, s.selected), u = selection('undismiss', s.rows, s.selected);
+      const f = picked('file'), d = picked('dismiss'), u = picked('undismiss');
       fileKey.textContent = f.count ? `File ${f.count} issue${f.count === 1 ? '' : 's'}` : 'File issues';
       fileKey.disabled = !f.enabled || s.busy; dismissKey.disabled = !d.enabled || s.busy;
       undismissKey.textContent = u.count ? `Undismiss ${u.count}` : 'Undismiss'; undismissKey.disabled = !u.enabled || s.busy;
-      actionNote.textContent = f.note || d.note || u.note || (s.selected.size ? `${f.count} open, ${u.count} dismissed selected` : '');
+      actionNote.textContent = f.note || d.note || u.note || (f.count + u.count ? `${f.count} open, ${u.count} dismissed selected` : '');
     }
     function setLamp(cls, text) {
       lamp.replaceChildren(el('i', undefined, 'lamp ' + cls), el('span', text));
     }
 
     // cells
+    const originCell = r => {
+      const marker = reviewMarker(r);
+      if (!marker) return r.origin || '—';
+      const box = el('span', undefined, 'fnd-status');
+      const lamp = el('i', undefined, 'lamp ' + marker.lamp);
+      lamp.title = marker.title;
+      box.title = marker.title;
+      box.append(lamp, el('span', r.origin || '—'), el('span', marker.label));
+      return box;
+    };
     const statusCell = r => {
       const st = statusOf(r), box = el('span', undefined, 'fnd-status fnd-' + st);
       box.append(el('i', undefined, 'lamp ' + (st === 'filed' ? 'fnd-amber' : st === 'fixed' ? 'st-pass' : 'lamp-off')));
@@ -223,6 +269,8 @@
       more.append(el('span', '▸', 'fnd-caret'));
       const detail = el('div', undefined, 'fnd-detail'); detail.hidden = true;
       detail.append(el('pre', r.text || r.summary || '', 'fnd-text'));
+      const marker = reviewMarker(r);
+      if (marker) detail.append(el('p', marker.sentence, 'muted'));
       const meta = el('dl', undefined, 'fnd-meta');
       for (const [k, v] of [['Reviewer', r.reviewer], ['Commit', r.commit], ['Fingerprint', r.fp], ['Plan', r.plan_dir || r.plan],
         ['Dismissed', r.dismissed ? `${r.dismissed.at || ''} ${r.dismissed.reason || ''}`.trim() : null]]) {
@@ -245,7 +293,7 @@
       cols.push(
         { id: 'severity', label: 'Severity', value: r => SEVERITIES.indexOf(r.severity), cell: sevCell },
         { id: 'confidence', label: 'Confidence', value: r => r.confidence, cell: r => r.confidence || '—' },
-        { id: 'origin', label: 'Origin', value: r => r.origin, cell: r => r.origin || '—' },
+        { id: 'origin', label: 'Origin', value: r => r.origin, cell: originCell },
         { id: 'task', label: 'Task', value: r => r.task, mono: true, cell: r => r.task || 'whole run' });
       if (s.scope === 'repo') cols.push({ id: 'plan', label: 'Plan', value: r => r.plan, mono: true, cell: r => r.plan || '—' });
       cols.push(
@@ -304,7 +352,7 @@
     // dismiss: an optional reason, then the call
     async function openDismiss() {
       reasonHost.replaceChildren();
-      const sel = selection('dismiss', s.rows, s.selected);
+      const sel = picked('dismiss');
       if (!sel.enabled) return;
       const l = el('label', undefined, 'fnd-field fnd-reason-field'), input = el('input');
       input.type = 'text'; input.maxLength = MAX_REASON; input.placeholder = 'why (optional)';
@@ -319,7 +367,7 @@
       input.focus();
     }
     async function doDismiss(undo, reason) {
-      const sel = selection(undo ? 'undismiss' : 'dismiss', s.rows, s.selected);
+      const sel = picked(undo ? 'undismiss' : 'dismiss');
       if (!sel.enabled || s.busy) return;
       s.busy = true; syncActions(); outcomeHost.replaceChildren();
       const res = await UI.post(dismissPath(key), dismissBody(sel.fps, reason, undo));
@@ -330,17 +378,19 @@
 
     // filing: drafts for exactly the selection, a preview, then the POST
     async function openFile() {
-      const sel = selection('file', s.rows, s.selected);
+      const sel = picked('file');
       if (!sel.enabled || s.busy) return;
       s.busy = true; syncActions(); outcomeHost.replaceChildren();
       setLamp('st-running', 'preparing the issue drafts…');
-      const res = await UI.get(issuesUrl(key, { scope: s.scope, offline: false, plausible: s.plausible, only: sel.fps }));
+      // The scope and the toggle stay usable while the drafts are made: the preview files what these drafts were made for.
+      const scope = s.scope, plausible = s.plausible;
+      const res = await UI.get(issuesUrl(key, { scope, offline: false, plausible, only: sel.fps }));
       s.busy = false; syncActions();
       if (!res.ok) { setLamp('st-fail', 'could not prepare the drafts'); UI.outcome(outcomeHost, res); return; }
       setLamp('st-pass', 'drafts ready');
-      preview(sel.fps, list(res.data.drafts));
+      preview(sel.fps, list(res.data.drafts), { scope, plausible });
     }
-    function preview(fps, drafts) {
+    function preview(fps, drafts, made) {
       dlg.replaceChildren();
       dlg.append(el('h2', 'File issues on GitHub'));
       const warn = el('p', undefined, 'fnd-warn');
@@ -373,7 +423,7 @@
         labelNote.hidden = !parsed.error; labelNote.textContent = parsed.error || '';
         if (parsed.error) return;
         go.disabled = true; cancel.disabled = true; labels.disabled = true; results.replaceChildren(); posting = true;
-        const res = await UI.post(issuesPath(key), fileBody(s.scope, fps, s.plausible, parsed.labels));
+        const res = await UI.post(issuesPath(key), fileBody(made.scope, fps, made.plausible, parsed.labels));
         posting = false;
         if (!res.ok) { go.disabled = false; cancel.disabled = false; labels.disabled = false; UI.outcome(results, res); return; }
         const lines = resultLines(res.data.created), ul = el('ul', undefined, 'fnd-created');
@@ -384,6 +434,7 @@
           ul.append(li);
         }
         results.replaceChildren(el('p', `${lines.filter(l => l.kind === 'created').length} created`, 'fnd-done'), ul);
+        for (const n of emptyNotes(res.data.created, res.data.notes)) results.append(el('p', n, 'muted fnd-result-note'));
         go.remove(); cancel.textContent = 'Close'; cancel.disabled = false;
         for (const fp of fps) s.selected.delete(fp);
         load();
@@ -407,6 +458,6 @@
     return { reload: load };
   }
 
-  return { render, statusOf, filterRows, mergeFiled, selectable, selection, issuesUrl, issuesPath, dismissPath, fileBody, dismissBody,
-    parseLabels, resultLines, safeUrl, MAX_FPS };
+  return { render, statusOf, filterRows, mergeFiled, selectable, selection, selectShownOpen, issuesUrl, issuesPath, dismissPath, fileBody, dismissBody,
+    parseLabels, resultLines, emptyNotes, safeUrl, reviewMarker, ORIGINS, MAX_FPS };
 });

package/ui/forge_ui/static/graph.js

@@ -201,8 +201,9 @@
       if (drawn[t.id]) return;
       drawn[t.id] = true;
       var p = pos[t.id];
-      var status = str(t.status, 'pending');
-      var stClass = 'st-' + status.toLowerCase().replace(/[^a-z0-9_-]/g, '');
+      var status = window.ForgeRunModel.taskStatus(t);
+      var verdict = window.ForgeRunModel.taskVerdict(t);
+      var stClass = 'st-' + String(status || 'pending').toLowerCase().replace(/[^a-z0-9_-]/g, '');
       var selected = options.selected === t.id;
       var id = String(t.id);
 
@@ -217,7 +218,7 @@
 
       var tip = [str(t.title, id), 'status: ' + status,
         'dwarf: ' + str(t.dwarf, '—') + ' / qa: ' + str(t.qa, '—')];
-      if (t.verdict) tip.push('verdict: ' + t.verdict);
+      if (verdict.text) tip.push('verdict: ' + verdict.text);
       if (t.explored) tip.push('explored');
       var title = el('title', null, g);
       title.textContent = tip.join('\n');
@@ -238,8 +239,8 @@
         x: 12, y: 36, 'font-size': 12, fill: 'currentColor', 'fill-opacity': 0.75
       });
 
-      if (t.verdict === 'PASS' || t.verdict === 'FAIL') {
-        var pass = t.verdict === 'PASS';
+      if (verdict.mark === 'PASS' || verdict.mark === 'FAIL') {
+        var pass = verdict.mark === 'PASS';
         // a drawn tick or cross, in the verdict's colour
         el('path', { 'class': 'fg-verdict' + (pass ? ' fg-pass' : ''), d: pass ? 'M' + (NODE_W - 20) + ' 12l4 4 7-8' : 'M' + (NODE_W - 19) + ' 8l8 8m0-8l-8 8',
           fill: 'none', 'stroke-width': 1.8, 'stroke-linecap': 'round', 'stroke-linejoin': 'round' }, g);

package/ui/forge_ui/static/leaderboard.js

@@ -149,6 +149,7 @@ window.ForgeLeaderboard = (() => {
     ['Verdicts', '', 'PASS and FAIL verdicts over every review'],
     ...MS.SEVERITIES.map(s => [s, 'lb-num', SEV_TITLE(s)]),
     ['Shadow agreement', 'lb-num', 'How often this model\'s shadow verdict matched the primary reviewer\'s (both PASS or FAIL)'],
+    ['Did not hold', 'lb-num', 'Of the work this model PASSed that was integrated, the share later reverted or with under 80% of its lines kept (forge dataset reviewers, every run in the dataset: the filters do not apply). Advisory: routing never reads it'],
     ['Median time', 'lb-num', 'Median duration of a review'],
     ['Tokens in / out', 'lb-num', 'Summed over the reviews that recorded tokens'],
   ];
@@ -182,7 +183,23 @@ window.ForgeLeaderboard = (() => {
     td.title = `${a.k} of ${a.n} shadow verdicts matched the primary's; 95% Wilson interval ${pct(a.lo)}–${pct(a.hi)}${a.unknown ? ` · ${a.unknown} without two comparable verdicts` : ''}`;
     return td;
   }
+  function heldCell(h) {
+    const days = h.horizon ? ` ${h.horizon} days after integrate` : '';
+    if (h.state === 'unavailable') return numCell('—', 'The run dataset could not be read (forge dataset reviewers)');
+    if (h.state === 'none') return numCell('—', `No work this model PASSed has a survival outcome${days} yet (forge dataset outcomes records them)`);
+    const detail = `${h.reverted} reverted, ${h.rewritten} rewritten, of ${h.n} PASSed and integrated${days}`;
+    if (h.state === 'few') {
+      const td = numCell('not enough data', `${detail}; a rate needs ${h.need || 'more'} outcomes`);
+      td.classList.add('muted');
+      return td;
+    }
+    const td = el('td', undefined, 'lb-num');
+    td.append(el('strong', pct(h.p)), document.createTextNode(' '), el('span', `${h.k}/${h.n}`, 'muted'));
+    td.title = `${detail}; 95% Wilson interval ${pct(h.lo)}–${pct(h.hi)}`;
+    return td;
+  }
   function reviewerTable(rows, ctx) {
+    const held = r => MS.heldUp(ctx.reviewerOutcomes, r.alias);
     const columns = colsOf(REV_COLS, [
       { id: 'model', value: r => r.alias, cell: r => modelCell(r.alias, ctx, '') },
       { id: 'primary', value: r => r.reviews.primary, cell: r => numCell(r.reviews.primary) },
@@ -191,6 +208,7 @@ window.ForgeLeaderboard = (() => {
       { id: 'verdicts', value: r => { const v = r.verdicts, t = v.PASS + v.FAIL + v.other; return t ? v.PASS / t : null; }, cell: r => verdictCell(r.verdicts) },
       ...MS.SEVERITIES.map(sv => ({ id: 'sev-' + sv, value: r => r.findings[sv], cell: r => findingCell(r, sv) })),
       { id: 'agreement', value: r => r.agreement.n ? r.agreement.p : null, cell: r => agreementCell(r.agreement) },
+      { id: 'held', value: r => { const h = held(r); return h.state === 'rate' ? h.p : null; }, cell: r => heldCell(held(r)) },
       { id: 'time', value: r => num(r.medianDurationS), cell: r => numCell(dur(r.medianDurationS)) },
       { id: 'tokens', value: r => (r.tokens.attempts ?? r.tokens.reviews) ? (r.tokens.input || 0) + (r.tokens.output || 0) : null, cell: r => tokenCell(r.tokens, r.reviews.total, 'review') },
     ]);

package/ui/forge_ui/static/modelstats.js

@@ -245,5 +245,23 @@
     return { implementers: imp.rows, reviewers: rev.rows, byDifficulty, totals, caveats, filter: f };
   }
 
-  return { DIFFS, KINDS, SEVERITIES, DEFAULT_MIN_N, wilson, emptyFilter, normFilter, taskMatch, options, leaderboard };
+  // How the work a reviewer PASSed held up, from GET /api/models/reviewers (`forge dataset reviewers --json`):
+  // { state: 'unavailable' } without a report, 'none' when the alias has no landed outcome, 'few' below the
+  // report's minimum (no rate is shown then), else 'rate' with the share that did not hold and its interval.
+  function heldUp(report, alias) {
+    const r = obj(report);
+    if (!r || !Array.isArray(r.reviewers)) return { state: 'unavailable' };
+    const horizon = num(r.horizon_days), row = r.reviewers.find(x => obj(x) && x.reviewer === alias);
+    if (!row) return { state: 'none', horizon };
+    const n = num(row.landed), k = num(row.did_not_hold);
+    if (n === null || k === null) return { state: 'unavailable' };
+    const base = { n, k, reverted: num(row.reverted) || 0, rewritten: num(row.rewritten) || 0, horizon };
+    const ci = list(row.ci);
+    if (row.enough !== true || num(row.rate) === null || num(ci[0]) === null || num(ci[1]) === null) {
+      return { state: 'few', need: num(r.min_landed), ...base };
+    }
+    return { state: 'rate', p: row.rate, lo: ci[0], hi: ci[1], ...base };
+  }
+
+  return { DIFFS, KINDS, SEVERITIES, DEFAULT_MIN_N, wilson, emptyFilter, normFilter, taskMatch, options, leaderboard, heldUp };
 });

package/ui/forge_ui/static/panel.js

@@ -9,7 +9,7 @@ window.ForgePanel = (() => {
   const num = v => typeof v === 'number' && Number.isFinite(v) ? v : null;
   const display = v => v === null || v === undefined || v === '' ? '—' : typeof v === 'object' ? JSON.stringify(v, null, 2) : String(v);
   const STATUSES = new Set(['merged', 'pass', 'running', 'pending', 'fail', 'error', 'infra', 'timeout', 'unknown', 'invalidated', 'blocked',
-    'interrupted', 'nochanges', 'conflict', 'accepted', 'none']);
+    'interrupted', 'nochanges', 'conflict', 'accepted', 'none', 'outdated']);
   const cache = new Map();                                  // path → {data, error, at}
   function el(tag, text, className) {
     const node = document.createElement(tag);
@@ -51,6 +51,7 @@ window.ForgePanel = (() => {
   function section(parent, title) { const s = el('section', undefined, 'insp-section'); s.append(el('h3', title)); parent.append(s); return s; }
   function details(parent, title, value, key, { open = false, cls = '' } = {}) {
     const d = el('details', undefined, cls); d.dataset.keep = key; if (open) d.open = true;
+    if (key && String(key).endsWith('known_issues')) d.id = key;
     const pre = el('pre', value); pre.dataset.scroll = key + '-text';
     d.append(el('summary', title), pre); parent.append(d); return d;
   }
@@ -60,6 +61,21 @@ window.ForgePanel = (() => {
     return a;
   }
   function muted(parent, text) { parent.append(el('p', text, 'muted')); }
+  // The acceptance chip is a key to the Known issues text in this panel, not another route.
+  function acceptedChip(task) {
+    const over = task.accepted_over === 'FAIL' || task.accepted_over === 'UNKNOWN' ? task.accepted_over : null;
+    const id = 'task-' + task.id + '-known_issues';
+    const a = el('a', over ? 'accepted over ' + over : 'accepted', 'chip st-accepted');
+    a.href = '#' + id;
+    a.addEventListener('click', event => {
+      event.preventDefault();
+      const node = document.getElementById(id);
+      if (!node) return;
+      node.open = true;
+      node.scrollIntoView({ block: 'nearest' });
+    });
+    return a;
+  }
   // who decided an escalation: policy, a human's retry --dwarf (retry) or a pin; older rows read as policy
   const sourcePlate = source => el('span', source || 'policy', 'plate src-plate src-' + String(source || 'policy').replace(/[^a-z]/g, ''));
   // the write controls of a plan run (task undefined) or of one of its tasks; a page without controls.js says it is read-only
@@ -218,11 +234,23 @@ window.ForgePanel = (() => {
     }
     const f = section(host, 'Finish');
     const F = RM.finishState(run);
-    if (run.kind === 'solo') fields(f, [['Verdict', chip(list(run.tasks)[0] && list(run.tasks)[0].verdict)]]);
+    if (run.kind === 'solo') {
+      const soloTask = list(run.tasks)[0];
+      const verdict = soloTask ? RM.taskVerdict(soloTask) : { text: null, status: 'unknown' };
+      fields(f, [['Verdict', chip(verdict.text, verdict.status)]]);
+    }
     else {
+      const finalSel = { kind: 'final' }, openFinal = () => ctx.onSelect(finalSel);
+      let finalValue;
+      if (F.final.status === 'OUTDATED') {
+        finalValue = el('a'); finalValue.href = ctx.hash(finalSel);
+        finalValue.addEventListener('click', e => { e.preventDefault(); openFinal(); });
+        finalValue.append(chip('OUTDATED'));
+      } else finalValue = link(F.final.status === 'NONE' ? 'not requested' : F.final.status, ctx.hash(finalSel), openFinal);
       fields(f, [['Integration', link(`${F.integration.merged}/${F.integration.total} merged`, ctx.hash({ kind: 'integration' }), () => ctx.onSelect({ kind: 'integration' }))],
         ['Verification', link(F.verification.status, ctx.hash({ kind: 'verification' }), () => ctx.onSelect({ kind: 'verification' }))],
-        ['Final review', link(F.final.status === 'NONE' ? 'not requested' : F.final.status, ctx.hash({ kind: 'final' }), () => ctx.onSelect({ kind: 'final' }))]]);
+        ['Final review', finalValue]]);
+      if (F.final.status === 'OUTDATED') muted(f, RM.reviewSinceLine(F.final));
       if (F.final.findings) findingCounts(f, F.final.findings);
     }
     if (list(run.deferrals).length) details(host, `Deferred tasks (${run.deferrals.length})`, run.deferrals.join('\n'), 'deferrals');
@@ -236,10 +264,13 @@ window.ForgePanel = (() => {
     const head = el('div', undefined, 'insp-head');
     head.append(el('h2', solo ? (task.title || 'Solo run') : `${task.id} · ${task.title || 'Untitled task'}`), el('div', solo ? 'solo task' : `task · wave ${display(task.wave)}`, 'insp-kind'));
     const chips = el('div', undefined, 'chips');
-    chips.append(chip(task.status));
-    if (task.verdict) chips.append(chip('review ' + task.verdict, task.verdict.toLowerCase()));
+    if (RM.taskStatus(task) === 'ACCEPTED') chips.append(acceptedChip(task));
+    else {
+      chips.append(chip(RM.taskStatus(task)));
+      if (task.accepted === true) chips.append(acceptedChip(task));
+      else if (task.verdict) chips.append(chip('review ' + task.verdict, task.verdict.toLowerCase()));
+    }
     if (task.explored) chips.append(el('span', '* explored', 'tag'));
-    if (task.accepted_by) chips.append(chip('accepted over FAIL', 'nochanges'));
     head.append(chips);
     const dl = diffLink(ctx, solo ? 'View the diff →' : 'View its diff, findings pinned to their lines →', { kind: 'task', task: task.id, source: 'current' }); if (dl) head.append(dl);
     host.append(head);
@@ -270,7 +301,7 @@ window.ForgePanel = (() => {
     for (const z of tp.zones) {
       const box = el('div', undefined, 'attempt');
       const row = list(task.attempts).filter(a => a.attempt === z.attempt).pop();
-      const h = el('div', undefined, 'attempt-head'); h.append(el('strong', z.name.toLowerCase())); if (row) h.append(chip(row.status), el('span', time(row.at), 'muted'));
+      const h = el('div', undefined, 'attempt-head'); h.append(el('strong', z.name.toLowerCase())); if (row) h.append(chip(RM.attemptStatus(task, row.attempt, row.status)), el('span', time(row.at), 'muted'));
       box.append(h);
       for (const pid of z.parts) {
         const p = tp.parts.find(x => x.id === pid); if (!p || p.planned) continue;
@@ -329,7 +360,8 @@ window.ForgePanel = (() => {
       const cs = section(host, 'Clef predictions');
       for (const [label, p] of preds) {
         const n = Number(String(label).match(/\d+/) || 1), outcome = list(task.attempts).filter(a => a.attempt === n).pop();
-        fields(cs, [[label, `p(pass) = ${display(p.p)} → ${outcome ? outcome.status : 'not finished'}`], ['Assignment', p.assignment ? plates([p.assignment.dwarf, p.assignment.qa]) : '—']]);
+        const happened = outcome ? RM.attemptStatus(task, outcome.attempt, outcome.status) : 'not finished';
+        fields(cs, [[label, `p(pass) = ${display(p.p)} → ${happened}`], ['Assignment', p.assignment ? plates([p.assignment.dwarf, p.assignment.qa]) : '—']]);
       }
     }
     // the prompts and the final messages
@@ -338,10 +370,18 @@ window.ForgePanel = (() => {
     else {
       const t = detail.data.texts || {};
       for (const [title, key] of [['Requirements (prompt.md)', 'prompt'], ['Intended approach', 'approach'], ['Retry findings', 'retry_findings'],
-        ['Dwarf prompt as assembled (dwarf.input)', 'dwarf_input'], ['Review prompt as assembled (qa.input)', 'qa_input'], ['Known issues', 'known_issues'], ['Accepted by', 'accepted_by']]) {
+        ['Dwarf prompt as assembled (dwarf.input)', 'dwarf_input'], ['Review prompt as assembled (qa.input)', 'qa_input']]) {
         if (t[key] != null) details(ps, title, t[key], `task-${task.id}-${key}`);
       }
     }
+    // Known issues is the text the acceptance chip opens. Accepted by keeps the reason, who, and when.
+    const texts = detail.data && detail.data.texts || null;
+    if (task.accepted === true || (texts && texts.known_issues != null)) {
+      const known = texts ? texts.known_issues : null;
+      details(ps, 'Known issues', known != null ? known : (detail.data ? '—' : 'Loading…'), `task-${task.id}-known_issues`);
+    }
+    const acceptedBy = texts && texts.accepted_by != null ? texts.accepted_by : task.accepted_by;
+    if (acceptedBy != null) details(ps, 'Accepted by', acceptedBy, `task-${task.id}-accepted_by`);
     if (task.dwarf_tail != null) details(ps, 'Dwarf final message', task.dwarf_tail, `task-${task.id}-dwarf_tail`);
     if (task.qa_tail != null) details(ps, 'Reviewer final message', task.qa_tail, `task-${task.id}-qa_tail`);
   }
@@ -475,10 +515,12 @@ window.ForgePanel = (() => {
       return;
     }
     const chips = el('div', undefined, 'chips');
-    chips.append(chip(pick.state === 'running' ? 'RUNNING' : pick.verdict || pick.state || 'unknown'));
+    const status = RM.finalStatus(pick);
+    chips.append(chip(status));
     if (pick.published) chips.append(el('span', 'published', 'tag'));
     chips.append(el('span', pick.source === 'integrate' ? 'during integrate' : 'forge review', 'tag'));
     head.append(chips);
+    if (status === 'OUTDATED') muted(host, RM.reviewSinceLine(pick));
     fields(host, [['Reviewer', plate(pick.spec)], ['Threshold', pick.threshold], ['Reviewed', pick.base || pick.tip ? `${String(pick.base || '?').slice(0, 10)}..${String(pick.tip || '?').slice(0, 10)}` : '—', true],
       ['Started', time(pick.started ?? pick.at)], ['Ended', time(pick.ended)], ['Duration', RM.fmtDur(pick.duration_s)]]);
     if (pick.execution) { const s = { kind: 'execution', task: null, exec: pick.execution }; host.append(link('Model, timings and exact prompt →', ctx.hash(s), () => ctx.onSelect(s))); }

package/ui/forge_ui/static/runmodel.js

@@ -113,7 +113,9 @@
     if (f.model && !list(run.models).some(m => alias(m) === f.model)) return false;
     if (f.ageDays && num(now) !== null && !(num(run.updated) !== null && run.updated >= now - f.ageDays * 86400)) return false;
     if (f.verdict) {
-      const v = run.final_review || run.verification_status || null;
+      // An outdated published review matches OUTDATED, not the verdict it gave.
+      const review = runReviewStatus(run);
+      const v = review != null ? review : (run.verification_status || null);
       if (f.verdict === 'none' ? v : v !== f.verdict) return false;
     }
     return true;
@@ -180,16 +182,116 @@
     if (statuses.some(s => s === 'PENDING' || s === 'PASS')) return 'PENDING';
     return 'BLOCKED';
   }
+  // How one final review reads as a stage. OUTDATED only once it is done and the reader says the
+  // integration branch has moved: a running review, and a review the reader still calls current, keep their verdict.
+  function finalStatus(fr) {
+    if (!fr || typeof fr !== 'object') return null;
+    if (fr.state === 'running') return 'RUNNING';
+    if (fr.state === 'infra') return 'INFRA';
+    if (fr.state === 'done' && fr.outdated === true) return 'OUTDATED';
+    return fr.verdict || 'UNKNOWN';
+  }
+  // RunSummary carries the published verdict as a string plus final_review_outdated. Same rule as finalStatus.
+  function runReviewStatus(summary) {
+    if (!summary) return null;
+    const v = summary.final_review;
+    if (v && typeof v === 'object') return finalStatus(v);
+    if (typeof v !== 'string' || !v) return null;
+    return summary.final_review_outdated === true ? 'OUTDATED' : v;
+  }
+  // The lamp and status word for a task. Accepting a merge does not change the recorded status
+  // or the run's counts: only the display says ACCEPTED, and only once the task has merged.
+  function taskStatus(t) {
+    if (!t) return 'PENDING';
+    if (t.status === 'MERGED' && t.accepted === true) return 'ACCEPTED';
+    return t.status || 'PENDING';
+  }
+  // Verdict column and the 2D graph's tick or cross. text is the words, status the lamp class,
+  // mark the cross (FAIL) or tick (PASS). An acceptance names FAIL or UNKNOWN and never invents a FAIL,
+  // and it draws no mark: the graph must not put a red cross on a task a human accepted.
+  function taskVerdict(t) {
+    if (taskStatus(t) === 'ACCEPTED') {
+      const over = t.accepted_over === 'FAIL' || t.accepted_over === 'UNKNOWN' ? t.accepted_over : null;
+      return { text: over ? over + ' · accepted' : 'accepted', status: 'accepted', mark: null };
+    }
+    const v = t && t.verdict ? String(t.verdict) : null;
+    return { text: v, status: v ? v.toLowerCase() : 'unknown', mark: v === 'PASS' || v === 'FAIL' ? v : null };
+  }
+  // One attempt in the history. The attempt that was accepted is ACCEPTED; every earlier attempt
+  // keeps the status it ended with. execStatus itself is unchanged, so a QA part still shows the
+  // reviewer's verdict and an execution detail does too.
+  function attemptStatus(task, attempt, raw) {
+    if (taskStatus(task) !== 'ACCEPTED') return raw;
+    const n = num(attempt), want = num(task.accepted_attempt);
+    if (n !== null && want !== null && n === want) return 'ACCEPTED';
+    return raw;
+  }
+  function shortTip(tip) {
+    if (tip === null || tip === undefined || tip === '') return '—';
+    return String(tip).slice(0, 7);
+  }
+  // "<verdict> at <tip7>; N tasks merged since: <ids>", ids cut after 5.
+  function reviewSinceLine(src) {
+    if (!src) return '';
+    const ids = list(src.merged_since).map(id => String(id));
+    const shown = ids.slice(0, 5), extra = ids.length - shown.length;
+    const names = shown.join(', ') + (extra > 0 ? ' +' + extra + ' more' : '');
+    const n = ids.length;
+    return `${src.verdict || 'UNKNOWN'} at ${shortTip(src.tip)}; ${n} ${n === 1 ? 'task' : 'tasks'} merged since` + (names ? ': ' + names : '');
+  }
+  // The newest final review that had started by t. Same pick stateAt has always made.
+  function reviewAt(run, t) {
+    const started = r => num(r && r.started) ?? num(r && r.at);
+    const fr = list(run && run.final_reviews).filter(r => r && (started(r) ?? Infinity) <= t);
+    return fr.sort((a, b) => (a.at || 0) - (b.at || 0)).pop() || null;
+  }
+  // When an outdated review starts to show as OUTDATED. The current flag is the truth; this only places it.
+  // First id in merged_since, else (that list is empty) the first merge at or after the review's `at`,
+  // else the review's end when no merge time is known. A current review (outdated false or null) has no moment.
+  function outdatedMoment(run, review) {
+    if (!review || review.outdated !== true) return null;
+    const merges = list(run && run.integration && run.integration.merged).filter(m => m && num(m.at) !== null);
+    const since = list(review.merged_since);
+    if (since.length) {
+      const times = merges.filter(m => m.id === since[0]).map(m => m.at);
+      if (times.length) return Math.min(...times);
+      return num(review.ended);
+    }
+    const at = num(review.at);
+    if (at !== null) {
+      const later = merges.filter(m => m.at >= at).map(m => m.at);
+      if (later.length) return Math.min(...later);
+    }
+    return num(review.ended);
+  }
+  // Status of one review at time t. Before it ends it is RUNNING. OUTDATED only at and after outdatedMoment,
+  // and only when the review is done and currently outdated, so the present matches finalStatus.
+  function finalAt(run, review, t) {
+    if (!review) return 'NONE';
+    if (review.state === 'running') return 'RUNNING';
+    const ended = num(review.ended);
+    const end = ended !== null ? ended : (review.state === 'done' || review.state === 'infra' ? num(review.at) : null);
+    if (end === null) return finalStatus(review) || 'RUNNING';
+    if (end > t) return 'RUNNING';
+    if (review.state === 'infra') return 'INFRA';
+    if (review.state === 'done' && review.outdated === true) {
+      const from = outdatedMoment(run, review);
+      if (from === null || t >= from) return 'OUTDATED';
+    }
+    return review.verdict || 'UNKNOWN';
+  }
   function finishState(run) {
     const fr = run.final_review, v = run.verification, ig = run.integration;
     const tasks = list(run.tasks), merged = tasks.filter(t => t.status === 'MERGED').length;
+    const frObj = fr && typeof fr === 'object' ? fr : null;
     return {
       integration: { status: integrationStatus(tasks.map(t => t.status)),
         merged, total: tasks.length, base: ig && ig.base || null, accepted: ig && ig.accepted || null },
       verification: { status: v && v.status ? String(v.status).toUpperCase() : 'PENDING', command: v && v.command || null, runs: list(v && v.runs).length },
-      final: { status: !fr ? (run.settings && run.settings.final_qa ? 'PENDING' : 'NONE') : fr.state === 'running' ? 'RUNNING' : fr.state === 'infra' ? 'INFRA' : fr.verdict || 'UNKNOWN',
-        requested: !!(fr || run.settings && run.settings.final_qa), spec: fr && fr.spec || run.settings && run.settings.final_qa || null, findings: fr && fr.findings || null,
-        count: list(run.final_reviews).length },
+      final: { status: !frObj ? (run.settings && run.settings.final_qa ? 'PENDING' : 'NONE') : finalStatus(frObj),
+        requested: !!(fr || run.settings && run.settings.final_qa), spec: frObj && frObj.spec || run.settings && run.settings.final_qa || null, findings: frObj && frObj.findings || null,
+        count: list(run.final_reviews).length,
+        verdict: frObj && frObj.verdict || null, tip: frObj && frObj.tip || null, merged_since: list(frObj && frObj.merged_since) },
     };
   }
   function planModel(run) {
@@ -221,6 +323,8 @@
     const put = (a, p) => { const k = a == null ? 'other' : String(a); if (!byAttempt.has(k)) byAttempt.set(k, []); byAttempt.get(k).push(p); };
     for (const e of execs) {
       if (e.role !== 'dwarf' && e.role !== 'qa') continue;
+      // The part keeps execStatus. The accepted attempt is relabelled by attemptStatus on the
+      // attempt itself; painting this part ACCEPTED would hide the reviewer's verdict.
       put(e.attempt, { id: e.id, kind: e.role, exec: e, status: execStatus(e), label: e.role === 'dwarf' ? 'DWARF' : 'QA', spec: e.model && e.model.spec || null, attempt: e.attempt });
     }
     for (const s of list(task && task.shadow)) {
@@ -359,11 +463,13 @@
         const start = num(e.started); if (start === null) continue;
         const kids = execs.filter(k => k !== e && (k.parent === e.id || e.synthetic || (tops.length === 1 && !k.parent && (k.role === 'dwarf' || k.role === 'qa'))));
         const row = rows.filter(r => r.attempt === e.attempt).pop();
-        const status = e.state === 'running' ? 'RUNNING' : row ? row.status : e.state === 'orphaned' ? 'INTERRUPTED' : t.status === 'MERGED' && e === tops[tops.length - 1] ? 'MERGED' : execStatus(e);
+        let status = e.state === 'running' ? 'RUNNING' : row ? row.status : e.state === 'orphaned' ? 'INTERRUPTED' : t.status === 'MERGED' && e === tops[tops.length - 1] ? 'MERGED' : execStatus(e);
+        if (e === tops[tops.length - 1] && t.status === 'MERGED') status = 'MERGED';
+        status = attemptStatus(t, e.attempt, status);
         const end = execEnd(e, now);
         const running = kids.find(k => k.state === 'running');
         items.push({ id: e.id, task: t.id, attempt: e.attempt, start, end: end !== null ? Math.max(end, start) : start, running: e.state === 'running',
-          status: e === tops[tops.length - 1] && t.status === 'MERGED' ? 'MERGED' : status, role: running ? running.role : null, phase: running ? running.phase : null,
+          status, role: running ? running.role : null, phase: running ? running.phase : null,
           segs: kids.filter(k => k.role === 'dwarf' || k.role === 'qa').map(k => ({ id: k.id, role: k.role, start: num(k.started), end: execEnd(k, now), status: execStatus(k) })).filter(s => s.start !== null) });
       }
     }
@@ -492,9 +598,8 @@
       }
       tasks[task.id] = { status, role };
     }
-    const fr = list(run && run.final_reviews).filter(r => (num(r.started) ?? num(r.at) ?? Infinity) <= t);
-    const last = fr.sort((a, b) => (a.at || 0) - (b.at || 0)).pop();
-    const final = !last ? 'NONE' : num(last.ended) !== null && last.ended <= t ? (last.verdict || 'UNKNOWN') : 'RUNNING';
+    const last = reviewAt(run, t);
+    const final = finalAt(run, last, t);
     const vs = list(run && run.timeline && run.timeline.verifications).filter(v => num(v.started) !== null && v.started <= t);
     const lv = vs.pop();
     const verification = !lv ? 'PENDING' : num(lv.ended) !== null && lv.ended <= t ? (lv.exit_code === 0 ? 'PASS' : 'FAIL') : 'RUNNING';
@@ -502,7 +607,15 @@
   }
   function timeRange(run, now) {
     const s = [], e = [];
-    for (const t of list(run && run.tasks)) for (const x of list(t.executions)) { if (num(x.started) !== null) s.push(x.started); const end = execEnd(x, now); if (end !== null) e.push(end); }
+    for (const t of list(run && run.tasks)) {
+      for (const x of list(t.executions)) { if (num(x.started) !== null) s.push(x.started); const end = execEnd(x, now); if (end !== null) e.push(end); }
+      // The merged marker is written after the attempt ends. Leave it out and the slider stops on the
+      // verdict while the current view already shows the review as OUTDATED.
+      if (num(t.merged_at) !== null) e.push(t.merged_at);
+    }
+    // Same marker, as integration.merged. That list is what outdatedMoment reads, and a run detail can carry it
+    // without the task's merged_at matching, so the range has to take it on its own.
+    for (const m of list(run && run.integration && run.integration.merged)) if (num(m && m.at) !== null) e.push(m.at);
     for (const r of list(run && run.final_reviews)) { const v = num(r.started) ?? num(r.at); if (v !== null) s.push(v); if (num(r.ended) !== null) e.push(r.ended); }
     for (const v of list(run && run.timeline && run.timeline.verifications)) { if (num(v.started) !== null) s.push(v.started); if (num(v.ended) !== null) e.push(v.ended); }
     if (!s.length) return null;
@@ -556,8 +669,9 @@
       if (r.kind === 'solo') continue;
       for (const t of list(r.task_statuses)) {
         if (!t || !t.id) continue;
-        out.push({ id: `task:${r.key}:${t.id}`, kind: 'task', key: r.key, task: t.id, label: t.title ? `${t.id} · ${t.title}` : t.id, sub: `${goal} · ${String(t.status || 'PENDING').toLowerCase()}`,
-          ids: [t.id], words: [r.run_id, basename(r.repo)].filter(Boolean), t: num(r.updated) || 0, status: t.status, subSearch: false,   // not found through its run's goal
+        const shown = taskStatus(t);
+        out.push({ id: `task:${r.key}:${t.id}`, kind: 'task', key: r.key, task: t.id, label: t.title ? `${t.id} · ${t.title}` : t.id, sub: `${goal} · ${String(shown).toLowerCase()}`,
+          ids: [t.id], words: [r.run_id, basename(r.repo)].filter(Boolean), t: num(r.updated) || 0, status: shown, subSearch: false,   // not found through its run's goal
           href: `#/runs/${encodeURIComponent(r.key)}/tasks/${encodeURIComponent(t.id)}` });
       }
     }
@@ -661,7 +775,8 @@
     return { pos, edges, cols, rows: next };
   }
 
-  return { liveNow, runState, execStatus, matchRun, filterOptions, atlasModel, columns, planModel, finishState, taskParts,
+  return { liveNow, runState, execStatus, matchRun, filterOptions, atlasModel, columns, planModel, finishState,
+    finalStatus, runReviewStatus, reviewSinceLine, reviewAt, taskStatus, taskVerdict, attemptStatus, taskParts,
     taskTimes, metricValue, overlap, projectSchedule, execModel, criticalPath, concurrency, stateAt, timeRange, events, lineage, structureKey, innerKey,
     fmtDur, alias, basename, weight, searchIndex, searchRank, statusEvents, fractalTree };
 });