@giamme/forge 0.10.0 → 0.11.1

package/ui/forge_ui/reader.py

@@ -42,6 +42,21 @@ def _kind(path):
     return None
 
 
+def _default_registry_dir():
+    """forge's run registry, resolved the way forge writes it (scripts/forge_registry.registry_dir).
+
+    ``XDG_CONFIG_HOME`` (``~`` expanded) when it is an absolute path, otherwise ``~/.config``: an
+    empty or relative value counts as unset (XDG spec), as it does when forge registers a run.
+    None only when even that is not absolute (a relative HOME): forge never registers a run
+    there, so reading it would only pick up whatever the current directory happens to hold.
+    """
+    value = os.environ.get('XDG_CONFIG_HOME') or ''
+    base = Path(value).expanduser() if value else None
+    if base is None or not base.is_absolute():
+        base = Path.home() / '.config'
+    return base / 'forge' / 'runs' if base.is_absolute() else None
+
+
 def discover(plans=(), roots=(), registry=True, registry_dir=None):
     found, seen = [], set()
 
@@ -76,10 +91,9 @@ def discover(plans=(), roots=(), registry=True, registry_dir=None):
     for path in roots:
         scan(Path(path))
     if registry:
-        base = Path(registry_dir) if registry_dir is not None else Path(
-            os.environ.get('XDG_CONFIG_HOME') or Path.home() / '.config') / 'forge' / 'runs'
+        base = Path(registry_dir) if registry_dir is not None else _default_registry_dir()
         try:
-            entries = sorted(base.glob('*.txt'))
+            entries = sorted(base.glob('*.txt')) if base is not None else []
         except OSError:
             entries = []
         for entry in entries:
@@ -310,10 +324,14 @@ def _tasks(reader):
             reader.warn(label, 'invalid task id')
             continue
         prefix = f'tasks/{ident}'
-        status = 'MERGED' if reader.exists(prefix + '/merged') else reader.word(prefix + '/status') or 'PENDING'
+        # One stat: the run list needs the mtime, and detail reads the same marker again.
+        merged = reader.stat(prefix + '/merged')
+        status = 'MERGED' if merged is not None else reader.word(prefix + '/status') or 'PENDING'
         tasks.append(dict(id=ident, title='\t'.join(row[6:]), deps=_list(deps),
                           difficulty=difficulty, files=_list(files), dwarf=_nullable(dwarf),
-                          qa=_nullable(qa), status=status))
+                          qa=_nullable(qa), status=status,
+                          merged_at=float(merged.st_mtime) if merged is not None else None,
+                          accepted=_nonempty(reader, prefix + '/accepted.by')))
     return tasks
 
 
@@ -353,12 +371,15 @@ def _summary(reader, source):
     final_review = reader.word('final-review.verdict')
     dwarf_models = sorted({task['dwarf'] for task in tasks if task['dwarf']})
     qa_models = sorted({task['qa'] for task in tasks if task['qa']})
+    # Before snapshotting `updated`: these reads are files the summary read, so a newer
+    # accepted.integration (or the published verdict / review.meta) moves the activity time.
+    final_review_outdated = _published_outdated(reader, tasks)
     result.update(updated=reader.updated, created=_created(reader.path, _PLAN_START_FILES),
                   task_count=len(tasks), counts=counts,
                   task_statuses=[dict(id=task['id'], status=task['status'], difficulty=task['difficulty'] or None,
-                                      title=_brief(task['title'])) for task in tasks],
+                                      title=_brief(task['title']), accepted=task['accepted']) for task in tasks],
                   models=sorted(set(dwarf_models) | set(qa_models)), dwarf_models=dwarf_models, qa_models=qa_models,
-                  final_review=final_review)
+                  final_review=final_review, final_review_outdated=final_review_outdated)
     return result, tasks
 
 
@@ -389,9 +410,10 @@ def _solo_summary(reader, source):
                 decompose_level=None, verification_status=None, updated=reader.updated,
                 created=_created(reader.path, _SOLO_START_FILES),
                 task_count=1, counts={status: 1},
-                task_statuses=[dict(id='solo', status=status, difficulty=None, title=_brief(goal or 'Solo run'))],
+                task_statuses=[dict(id='solo', status=status, difficulty=None, title=_brief(goal or 'Solo run'),
+                                    accepted=False)],
                 models=sorted({dwarf, qa} - {None}), dwarf_models=[dwarf] if dwarf else [],
-                qa_models=[qa] if qa else [], final_review=None)
+                qa_models=[qa] if qa else [], final_review=None, final_review_outdated=None)
 
 
 def summarize(path, source='plan') -> dict:
@@ -502,6 +524,26 @@ def _shadows(reader, ident, task_execs):
     return result
 
 
+def _accepted_fields(reader, name, text):
+    """(attempt, over) from an accepted.by body. A non-integer attempt= is null and warned.
+
+    status= FAIL or UNKNOWN is what was accepted over; any other or missing value is null
+    (a PASS record is an acceptance with nothing to say beyond "accepted").
+    """
+    if not text:
+        return None, None
+    fields = executions.parse_resolved(text)
+    attempt = None
+    raw = fields.get('attempt')
+    if raw:
+        try:
+            attempt = int(raw)
+        except (ValueError, OverflowError):
+            reader.warn(name, 'attempt is not an integer')
+    status = fields.get('status')
+    return attempt, status if status in ('FAIL', 'UNKNOWN') else None
+
+
 def _task_detail(reader, task, run_id, waves, branches):
     """Fill in a plan task; returns every execution it read (its own and its shadows')."""
     ident = task['id']
@@ -520,6 +562,8 @@ def _task_detail(reader, task, run_id, waves, branches):
     task['qa_tail'] = reader.cap(qa, prefix + '/qa_tail', 4000, True)
     task['dwarf_tail'] = reader.cap(reader.text(prefix + '/dwarf.last'), prefix + '/dwarf_tail', 4000, True)
     task['accepted_by'] = reader.text(prefix + '/accepted.by')
+    task['accepted_attempt'], task['accepted_over'] = _accepted_fields(
+        reader, prefix + '/accepted.by', task['accepted_by'])
     for field, filename in [('prompt', 'prompt.md'), ('approach', 'approach.md'), ('retry_findings', 'retry_findings.md')]:
         task[field] = reader.cap(reader.text(prefix + '/' + filename), prefix + '/' + field)
     task['route'] = []
@@ -606,6 +650,120 @@ def _published(reader):
     return real if executions.inside(reader.path, real) else None
 
 
+def _review_clock(reader, name):
+    """(source, at) of a `final-review-<e>-<p>` or `integrate-<e>-<p>` dir name, else None.
+
+    `at` is the whole-second epoch in the name. The same clock `executions.review_dirs` uses,
+    so a summary does not have to scan the plan to know when the published review started.
+    """
+    match = executions._KIND.fullmatch(name)
+    if not match:
+        return None
+    kind, epoch, _pid = match.groups()
+    if len(epoch) > 15:
+        reader.warn(name, 'invalid epoch')
+        return None
+    try:
+        at = float(epoch)
+        if not math.isfinite(at):
+            raise ValueError()
+    except (ValueError, OverflowError):
+        reader.warn(name, 'invalid epoch')
+        return None
+    return ('review' if kind == 'final-review' else 'integrate'), at
+
+
+def _published_identity(reader):
+    """(source, at) of the dir `final-review` links to, when the link stays inside the plan."""
+    real = _published(reader)
+    if real is None:
+        return None
+    path = Path(real)
+    # An integrate review is `<integrate-dir>/final-review`; a final-review dir is named itself.
+    if path.name == 'final-review':
+        found = _review_clock(reader, path.parent.name)
+        return found if found is not None and found[0] == 'integrate' else None
+    found = _review_clock(reader, path.name)
+    return found if found is not None and found[0] == 'review' else None
+
+
+def _merge_pairs(tasks):
+    """(id, merged_at) of every merged task, oldest merge first, then id."""
+    pairs = [(task['id'], task['merged_at']) for task in tasks if task.get('merged_at') is not None]
+    pairs.sort(key=lambda item: (item[1], item[0]))
+    return pairs
+
+
+# What `git rev-parse` writes for a commit: sha1 (40) or sha256 (64), lowercase hex.
+_COMMIT = re.compile(r'(?:[0-9a-f]{40}|[0-9a-f]{64})')
+
+
+def _meta_integration(reader, name, meta):
+    """The `integration=` commit of a review.meta, or None.
+
+    Missing or empty is absent (older runs record no integration commit). Any other value
+    that is not a commit object name is malformed: null, and a warning, so freshness uses
+    the next rule instead of treating the text as the commit the review judged.
+    """
+    value = meta.get('integration') or None
+    if not value:
+        return None
+    if _COMMIT.fullmatch(value):
+        return value
+    reader.warn(name, 'integration is not a commit')
+    return None
+
+
+def _review_freshness(accepted, integration, tip, source, at, merges, verdict):
+    """(outdated, merged_since) for one final review.
+
+    Null when the review has no verdict or there is no `accepted.integration` to compare with.
+    Otherwise the first rule that applies: a known `integration` commit, else `tip` when
+    `source` is `review`, else (an older integrate review) any task merged after `at`.
+    `integration` is a commit object name or None (a malformed value is None). A merge counts
+    when its marker mtime is `>= at + 1`. `merged_since` is those ids, oldest first, and is
+    empty unless the review is outdated.
+    """
+    later = []
+    if at is not None:
+        later = [item for item in merges if item[1] is not None and item[1] >= at + 1]
+        later.sort(key=lambda item: (item[1], item[0]))
+    ids = [task_id for task_id, _merged_at in later]
+    if not verdict or not accepted:
+        return None, []
+    if integration:
+        moved = integration != accepted
+    elif source == 'review':
+        moved = tip != accepted
+    else:
+        moved = bool(ids)
+    return (True, ids) if moved else (False, [])
+
+
+def _stamp_review(summary, accepted, merges):
+    summary['outdated'], summary['merged_since'] = _review_freshness(
+        accepted, summary['integration'], summary['tip'], summary['source'], summary['at'], merges,
+        summary['verdict'])
+    return summary
+
+
+def _published_outdated(reader, tasks):
+    """final_review_outdated for the published review only.
+
+    Reads `accepted.integration` and, through the `final-review` link, that dir's `verdict`
+    and `review.meta`. Does not scan other review dirs or open a review's attempts.
+    """
+    found = _published_identity(reader)
+    if found is None:
+        return None
+    source, at = found
+    verdict = reader.word('final-review/verdict')
+    meta = executions.parse_resolved(reader.text('final-review/review.meta'))
+    return _review_freshness(reader.line('accepted.integration'),
+                             _meta_integration(reader, 'final-review/review.meta', meta),
+                             meta.get('tip') or None, source, at, _merge_pairs(tasks), verdict)[0]
+
+
 def _final_review(reader, item, newest, published):
     """(FinalReviewSummary, its executions, review.meta) of one review dir."""
     name, source, at, rel = item
@@ -630,6 +788,8 @@ def _final_review(reader, item, newest, published):
                    verdict=verdict, state=state, spec=meta.get('spec') or None,
                    threshold=None if threshold == 'none' else threshold,
                    base=meta.get('base') or None, tip=meta.get('tip') or None,
+                   integration=_meta_integration(reader, rel + '/review.meta', meta),
+                   outdated=None, merged_since=[],
                    gate=_gate(reader, rel + '/qa.gate'), findings=executions.qa_result(reader, rel + '/qa.last')[1],
                    execution=run['id'] if run else None, started=run['started'] if run else None,
                    ended=run['ended'] if run else None, duration_s=run['duration_s'] if run else None)
@@ -701,6 +861,7 @@ def _solo_detail(reader, source):
                 dwarf=_role_spec(reader, 'dwarf'), qa=_role_spec(reader, 'qa'), wave=1, status=status,
                 branch=None, attempt=max((item['attempt'] for item in attempts), default=None),
                 attempts=attempts, escalations=[], verdict=_verdict(qa), accepted_by=None,
+                accepted=False, accepted_attempt=None, accepted_over=None,
                 explored=False, route=[], clef={'first_pass': None, 'retry_pass': {}}, shadow=[],
                 prompt=reader.cap(reader.text('prompt.md'), 'tasks/solo/prompt'), approach=None,
                 retry_findings=None, qa_tail=reader.cap(qa, 'tasks/solo/qa_tail', 4000, True),
@@ -767,6 +928,10 @@ def detail(path, source='plan') -> dict:
     result['timeline'] = _timeline(pool + run_execs, [item for item in run_execs if item['role'] == 'parallel'],
                                    [item for item in run_execs if item['role'] == 'verification'])
     result['integration'] = _integration(reader, tasks, integrations, reviews, published)
+    accepted = result['integration']['accepted'] if result['integration'] is not None else None
+    merges = [(item['id'], item['at']) for item in result['integration']['merged']] if result['integration'] else []
+    for summary in reviews:
+        _stamp_review(summary, accepted, merges)
     result['final_review'] = reviews[0] if reviews else None
     result['final_reviews'] = reviews
     result['deferrals'] = [line.strip() for line in (reader.text('deferrals.txt') or '').splitlines() if line.strip()]
@@ -943,6 +1108,7 @@ def final_review_detail(path, name, source='plan'):
     if index is None:
         return None
     summary, _, meta = _final_review(reader, items[index], index == 0, _published(reader))
+    _stamp_review(summary, reader.line('accepted.integration'), _merge_pairs(_tasks(reader)))
     rel = items[index][3]
     qa_last = reader.text(rel + '/qa.last')
     result = dict(summary)
@@ -1215,8 +1381,13 @@ def run_findings(path, source='plan'):
     if kind is None:
         return None
     keys = ('kind', 'execution', 'attempt', 'spec', 'verdict')
+    if kind == 'solo':
+        task_ids, merges, accepted = ['solo'], [], None
+    else:
+        rows = _tasks(reader)
+        task_ids, merges, accepted = [task['id'] for task in rows], _merge_pairs(rows), reader.line('accepted.integration')
     tasks = []
-    for task_id in ['solo'] if kind == 'solo' else [task['id'] for task in _tasks(reader)]:
+    for task_id in task_ids:
         ctx = _diff_task(reader, task_id)
         reviews = [dict({key: review[key] for key in keys}, findings=found)
                    for review in (ctx['reviews'] if ctx else []) for found in [_findings_of(reader, review)] if found]
@@ -1227,13 +1398,15 @@ def run_findings(path, source='plan'):
         items, published = executions.review_dirs(reader)[0], _published(reader)
         for index, item in enumerate(items[:_MAX_REVIEWS]):
             summary = _final_review(reader, item, index == 0, published)[0]
+            _stamp_review(summary, accepted, merges)
             # the same review final_review_diff pins, so a Finding's id opens it there
             review = _diff_review('final', None, None, summary['spec'], summary['verdict'], item[3] + '/qa.last', [],
                                   summary['execution'])
             found = _findings_of(reader, review)
             if found:
                 finals.append(dict(name=item[0], execution=summary['execution'], spec=summary['spec'],
-                                   verdict=summary['verdict'], findings=found))
+                                   verdict=summary['verdict'], outdated=summary['outdated'],
+                                   merged_since=summary['merged_since'], findings=found))
     return dict(run=run_key(reader.path), available=findings.available(), tasks=tasks, final_reviews=finals,
                 truncated=reader.truncated, warnings=reader.warnings)
 

package/ui/forge_ui/static/app.js

@@ -19,7 +19,7 @@ window.ForgeApp = (() => {
     replay: null, playing: null, speed: store.get('speed', 60), stage: null, stageFailed: null, stageLoading: false, timer: null,
     lastStatuses: new Map(), announced: 0, rendered: null, cloud: null, cloudUI: null, cloudPrefs: store.get('cloud', {}),
     settings: false, lastKey: null, settingsRun: null, settingsPickedAt: null, settingsView: null,
-    models: false, modelsData: null, modelsText: null, modelsError: null, modelsPrefs: store.get('models', {}),
+    models: false, modelsData: null, modelsText: null, modelsError: null, reviewerOutcomes: null, modelsPrefs: store.get('models', {}),
     files: new Map(), findingsCount: new Map(), filesPrefs: store.get('files', {}), runSort: store.get('run-sort', 'updated'), tablePrefs: store.get('tables', {}),
     findings: new Map() };
   state.stageMode = state.mode === 'exec' ? 'exec' : 'plan';   // the stage's own mode, kept while Files is shown
@@ -106,9 +106,9 @@ window.ForgeApp = (() => {
   function link(text, key, sel) { const a = el('a', text); a.href = hashFor(key, sel); return a; }
 
   const statuses = new Set(['merged', 'pass', 'running', 'pending', 'fail', 'error', 'infra',
-    'timeout', 'unknown', 'invalidated', 'blocked', 'interrupted', 'nochanges', 'conflict']);
-  function chip(value) {
-    const status = String(value || 'unknown').toLowerCase();
+    'timeout', 'unknown', 'invalidated', 'blocked', 'interrupted', 'nochanges', 'conflict', 'accepted', 'outdated']);
+  function chip(value, cls) {
+    const status = String(cls || value || 'unknown').toLowerCase();
     return el('span', value || '—', 'chip st-' + (statuses.has(status) ? status : 'unknown'));
   }
   function time(value) {
@@ -251,7 +251,8 @@ window.ForgeApp = (() => {
         if (!solo) {
           const verification = el('span', undefined, 'verification');
           verification.append(document.createTextNode('Verification '), chip(run.verification_status));
-          if (run.final_review) verification.append(document.createTextNode(' Review '), chip(run.final_review));
+          const reviewStatus = RM.runReviewStatus(run);
+          if (reviewStatus) verification.append(document.createTextNode(' Review '), chip(reviewStatus));
           item.append(verification);
         }
         $('run-list').append(item);
@@ -338,7 +339,7 @@ window.ForgeApp = (() => {
     add('Kind', sel('kind', [['', 'any'], ['plan', 'plan'], ['solo', 'solo']]));
     add('Model', sel('model', [['', 'any'], ...opts.models.map(m => [m, m])]));
     add('Age', sel('ageDays', [[0, 'any'], [1, 'last day'], [7, 'last week'], [30, 'last month']]));
-    add('Review', sel('verdict', [['', 'any'], ['PASS', 'passed'], ['FAIL', 'failed'], ['none', 'no verdict']]));
+    add('Review', sel('verdict', [['', 'any'], ['PASS', 'passed'], ['FAIL', 'failed'], ['OUTDATED', 'outdated'], ['none', 'no verdict']]));
     const all = el('input'); all.type = 'checkbox'; all.checked = state.showAll; all.dataset.f = 'showAll';
     const allL = el('label', undefined, 'filter check'); allL.append(all, document.createTextNode(' older runs too')); bar.append(allL);
     const reset = el('button', 'Reset'); reset.type = 'button'; reset.addEventListener('click', () => { Object.assign(state.mapFilter, { text: '', state: '', repo: '', kind: '', model: '', ageDays: 0, verdict: '' }); state.showAll = false; filterChanged(true); });
@@ -368,7 +369,12 @@ window.ForgeApp = (() => {
         card.className = `map-card st-${({ live: 'running', failed: 'fail', done: 'merged', pending: 'pending' })[m.state]}${m.match ? '' : ' dim'}`;
         card.append(el('strong', String(r.goal || 'Untitled run').split('\n')[0]), el('span', `${r.run_id || ''}${r.kind === 'solo' ? ' · solo' : ''}`, 'mono muted'));
         const leds = el('span', undefined, 'leds');
-        for (const t of m.tasks.slice(0, 60)) { const l = el('i', undefined, 'led st-' + String(t.status || 'pending').toLowerCase()); l.title = `${t.id}: ${t.status}`; leds.append(l); }
+        for (const t of m.tasks.slice(0, 60)) {
+          const status = RM.taskStatus(t);
+          const l = el('i', undefined, 'led st-' + String(status || 'pending').toLowerCase());
+          l.title = `${t.id}: ${status}`;
+          leds.append(l);
+        }
         card.append(leds, el('span', relative(r.updated), 'muted'));
         grid.append(card);
       }
@@ -474,15 +480,23 @@ window.ForgeApp = (() => {
       runs: state.runs, prefs: state.modelsPrefs, now: () => Date.now() / 1000,
       savePrefs: p => { state.modelsPrefs = p; store.set('models', p); },
       tablePrefs: id => state.tablePrefs[id], saveTablePrefs: (id, p) => { state.tablePrefs = { ...state.tablePrefs, [id]: p }; store.set('tables', state.tablePrefs); },
-      modelHref: alias => '#/cloud/models/' + encodeURIComponent(alias),
+      modelHref: alias => '#/cloud/models/' + encodeURIComponent(alias), reviewerOutcomes: state.reviewerOutcomes,
     });
   }
+  // How each reviewer's PASSed work held up (forge dataset reviewers). Advisory and optional: read once per
+  // change of the models data, and a failure (an export, no dataset) only leaves the column empty.
+  function loadReviewerOutcomes() {
+    if (SNAP) return;
+    fetchJSON('/api/models/reviewers').then(result => { state.reviewerOutcomes = result.data; },
+      () => { state.reviewerOutcomes = null; }).then(() => { if (state.models) renderModels(); });
+  }
   function loadModels() {
     return request('/api/models', result => {
       state.modelsError = null;
       if (result.text === state.modelsText) return;
       state.modelsText = result.text; state.modelsData = result.data;
       if (state.models) renderModels();
+      loadReviewerOutcomes();
     }, 'Could not refresh the model results', error => { state.modelsError = error.message; if (state.models) renderModels(); });
   }
 
@@ -741,11 +755,11 @@ window.ForgeApp = (() => {
       { id: 'title', label: 'Title', value: t => t.title },
       { id: 'difficulty', label: 'Difficulty', value: t => DIFF_RANK[t.difficulty] ?? null, cell: t => display(t.difficulty) },
       { id: 'wave', label: 'Wave', value: t => Number.isFinite(Number(t.wave)) && t.wave !== null && t.wave !== '' ? Number(t.wave) : null, cell: t => display(t.wave) },
-      { id: 'status', label: 'Status', value: t => t.status, cell: t => chip(t.status) },
+      { id: 'status', label: 'Status', value: t => RM.taskStatus(t), cell: t => chip(RM.taskStatus(t)) },
       { id: 'dwarf', label: 'Dwarf', value: t => t.dwarf, cell: t => window.ForgeIcons.modelPlate(t.dwarf) },
       { id: 'qa', label: 'QA', value: t => t.qa, cell: t => window.ForgeIcons.modelPlate(t.qa) },
       { id: 'attempt', label: 'Attempt', value: t => Number(t.attempt) || null, cell: t => display(t.attempt) },
-      { id: 'verdict', label: 'Verdict', value: t => t.verdict, cell: t => chip(t.verdict) },
+      { id: 'verdict', label: 'Verdict', value: t => RM.taskVerdict(t).text, cell: t => { const v = RM.taskVerdict(t); return chip(v.text, v.status); } },
       { id: 'findings', label: 'Findings', title: 'The worst confirmed severity and how many; ~n plausible only',
         value: t => t.findings && t.findings.worst ? SEV_RANK[t.findings.worst] * 1000 - (t.findings[t.findings.worst] || 0) : t.findings && t.findings.plausible ? 4000 : null,
         cell: t => { const f = t.findings, v = sev(f); if (!f || !f.worst) return v; const n = el('span', v, 'sev-chip sev-' + f.worst); return n; } },

package/ui/forge_ui/static/cloud3d.js

@@ -427,9 +427,12 @@ export function createCloud(E, host, cb = {}) {
   function info(el) {
     const f = el.f, r = f.run, counts = Object.entries(r.counts || {}).map(([s, n]) => `${s.toLowerCase()} ${n}`).join(' · ');
     const proj = st.L && st.L.projects.find(p => p.id === f.project);
+    const verdict = r.final_review && typeof r.final_review === 'object' ? r.final_review.verdict : r.final_review;
+    const isOutdated = verdict && RM.runReviewStatus(r) === 'OUTDATED';
+    const reviewText = verdict ? (isOutdated ? `${verdict} (outdated)` : verdict) : null;
     return [['meta', `${proj ? proj.name : RM.basename(r.repo)} · ${r.run_id || ''} · ${r.kind}`], ['title', String(r.goal || 'Untitled run').split('\n')[0]],
       ['body', `${f.n} task${f.n > 1 ? 's' : ''} · ${counts}`], ['body', `${[...f.dwarf].join(', ') || '—'} → ${[...f.qa].join(', ') || '—'}`],
-      ['foot', `started ${new Date(f.t * 1000).toLocaleString()}${r.final_review ? ' · review ' + r.final_review : ''}${r.verification_status ? ' · verify ' + r.verification_status : ''}`],
+      ['foot', `started ${new Date(f.t * 1000).toLocaleString()}${reviewText ? ' · review ' + reviewText : ''}${r.verification_status ? ' · verify ' + r.verification_status : ''}`],
       ['foot', (store.layouts[st.layout] || {})[el.key] ? 'moved by you · drag to move, Shift = depth, Alt = height' : 'drag to move · double-click to open']];
   }
   function showTip(el, cx, cy) {

package/ui/forge_ui/static/cloudmodel.js

@@ -63,7 +63,7 @@
     const aliases = specs => new Set(list(specs).map(RM.alias).filter(Boolean));
     return { key: run.key, run, project: hashId(run.repo || '?'), n, bucket: bucket(n), diff, dominant, state, t: startOf(run),
       dwarf: aliases(run.dwarf_models || run.models), qa: aliases(run.qa_models || []), all: aliases(run.models),
-      review: run.final_review || null, verification: run.verification_status || null, decompose: run.decompose_level || null, kind: run.kind };
+      review: RM.runReviewStatus(run) || null, verification: run.verification_status || null, decompose: run.decompose_level || null, kind: run.kind };
   }
 
   /* ---------- filters: the cloud shows exactly the runs that match ---------- */

package/ui/forge_ui/static/cloudui.js

@@ -254,7 +254,7 @@ window.ForgeCloudUI = (() => {
       }
       const more = el('fieldset', undefined, 'cloud-field cloud-more'); more.append(el('legend', 'More'));
       more.append(select('Active', 'active', [[0, 'any time'], [1, 'in the last day'], [7, 'in the last week'], [30, 'in the last month'], [90, 'in the last 3 months']], () => f.activeDays, v => { f.activeDays = Number(v) || 0; }));
-      more.append(select('Final review', 'review', [['', 'any'], ['PASS', 'passed'], ['FAIL', 'failed'], ['none', 'no verdict']], () => f.review, v => { f.review = v; }));
+      more.append(select('Final review', 'review', [['', 'any'], ['PASS', 'passed'], ['FAIL', 'failed'], ['OUTDATED', 'outdated'], ['none', 'no verdict']], () => f.review, v => { f.review = v; }));
       more.append(select('Verification', 'verification', [['', 'any'], ['PASS', 'passed'], ['FAIL', 'failed'], ['none', 'not run']], () => f.verification, v => { f.verification = v; }));
       const dec = Object.keys(O.decompose);
       if (dec.length > 1) more.append(chips('Decompose', dec.map(k => [k, k === 'none' ? 'off' : k, O.decompose[k]]), () => f.decompose, v => { f.decompose = v; }));
@@ -290,13 +290,22 @@ window.ForgeCloudUI = (() => {
       head.append(shut);
       card.append(head, el('h2', String(r.goal || 'Untitled run').split('\n')[0]), el('p', r.run_id || '', 'mono muted'));
       const leds = el('span', undefined, 'leds');
-      for (const t of list(r.task_statuses).slice(0, 120)) { const l = el('i', undefined, 'led st-' + String(t.status || 'pending').toLowerCase()); l.title = `${t.id}: ${t.status}${t.title ? ' · ' + t.title : ''}`; leds.append(l); }
+      for (const t of list(r.task_statuses).slice(0, 120)) {
+        const st = RM.taskStatus(t);
+        const l = el('i', undefined, 'led st-' + String(st || 'pending').toLowerCase());
+        l.title = `${t.id}: ${st}${t.title ? ' · ' + t.title : ''}`;
+        leds.append(l);
+      }
       card.append(leds);
       const dl = el('dl', undefined, 'fields');
       const mix = ['high', 'medium', 'low', 'none'].filter(k => f.diff[k]).map(k => `${f.diff[k]} ${k === 'none' ? 'unset' : k}`).join(' · ');
       const plates = specs => { if (!specs.length || !window.ForgeIcons) return specs.join(', ') || '—'; const s = el('span', undefined, 'plates'); for (const x of specs) s.append(window.ForgeIcons.modelPlate(x)); return s; };
+      const verdict = r.final_review && typeof r.final_review === 'object' ? r.final_review.verdict : r.final_review;
+      const isOutdated = verdict && RM.runReviewStatus(r) === 'OUTDATED';
+      const reviewText = verdict ? (isOutdated ? `${verdict} (outdated)` : verdict) : '—';
+      const reviewVal = isOutdated ? el('span', reviewText, 'chip st-outdated') : reviewText;
       for (const [k, v, mono] of [['Tasks', `${f.n}${mix ? ' · ' + mix : ''}`], ['Implementers', plates([...f.dwarf])], ['Reviewers', plates([...f.qa])],
-        ['Started', when(r.created)], ['Updated', when(r.updated)], ['Final review', r.final_review || '—'], ['Verification', r.verification_status || '—'], ['Decompose', r.decompose_level || 'off']]) {
+        ['Started', when(r.created)], ['Updated', when(r.updated)], ['Final review', reviewVal], ['Verification', r.verification_status || '—'], ['Decompose', r.decompose_level || 'off']]) {
         const dd = el('dd', undefined, mono ? 'mono' : ''); dd.append(v instanceof Node ? v : document.createTextNode(String(v))); dl.append(el('dt', k), dd);
       }
       card.append(dl);
@@ -345,7 +354,7 @@ window.ForgeCloudUI = (() => {
           a.href = '#/runs/' + encodeURIComponent(r.key);
           a.append(el('strong', String(r.goal || 'Untitled run').split('\n')[0]), el('span', `${r.run_id || ''} · ${f.n} task${f.n === 1 ? '' : 's'}${r.kind === 'solo' ? ' · solo' : ''}`, 'mono muted'));
           const leds = el('span', undefined, 'leds');
-          for (const t of list(r.task_statuses).slice(0, 60)) leds.append(el('i', undefined, 'led st-' + String(t.status || 'pending').toLowerCase()));
+          for (const t of list(r.task_statuses).slice(0, 60)) leds.append(el('i', undefined, 'led st-' + String(RM.taskStatus(t) || 'pending').toLowerCase()));
           a.append(leds); grid.append(a);
         }
         g.append(grid); listHost.append(g);