Close the gaps: every task per collection, filters in the URL, filterable jobs; cut repeated information.

Tasks: the mock lists every task with outcomes that match each collection's gate counts exactly; live lists every task of each pinned revision from its static-gate report (codes in plain words, excluded / needs controls / passed). /api/app/tasks filters and pages on the server. Every list keeps its search, filters and sort in the URL. Compute lists only jobs that belong to no run, with search and status filters. The submission page drops its summary boxes and timeline for one status line; the run page drops details its header already shows; the Runs page folds its panels into one line of filter links.

app_api.py

@@ -159,8 +159,6 @@ def submission(collection_id: str, source: str = Source):
             if r['state'] in ('running', 'queued'): r['progress'] = progress(r, r['stages'], r['steps_done'], r['steps_total'], med.get(r['challenge_id'], {}), now)
         latest = next((r for r in reversed(runs) if steps.get(r['id'], 0) > 2), None)
         curve = [dict(step=s['step'], t=s['t'], **json.loads(s['metrics'])) for s in rows(con, 'SELECT * FROM run_steps WHERE run_id = ? ORDER BY step', latest['id'])] if latest else []
-        learnt_run = next((r for r in reversed(runs) if one(con, 'SELECT 1 x FROM run_task_stats WHERE run_id = ? LIMIT 1', r['id'])), None)
-        learnt = rows(con, 'SELECT * FROM run_task_stats WHERE run_id = ?', learnt_run['id']) if learnt_run else []
         board = [parse(b, 'suites', 'run_ids') for b in rows(con, 'SELECT * FROM board WHERE collection_id = ?', collection_id)]
         timeline = [{'t': c['created_at'], 'what': 'submitted', 'detail': f"{c['task_count']} tasks"}]
         for r in runs:
@@ -172,10 +170,9 @@ def submission(collection_id: str, source: str = Source):
         mine_q = [q for q in queue_of(con, now) if q['collection_id'] == collection_id]
         for q in mine_q: timeline.append({'t': q['requested_at'], 'what': 'run queued', 'detail': f"{q['challenge_id']}, number {q['position']} in line"})
         timeline.sort(key=lambda x: (x['t'] or '', x.get('order', 0)))
-        return {**c, 'tasks': rows(con, 'SELECT name, category, outcome, passes, why FROM tasks WHERE collection_id = ?', collection_id), 'runs': runs, 'board': board,
+        return {**c, 'runs': runs, 'board': board,
                 'queued': [q['challenge_id'] for q in mine_q], 'queue': mine_q,
-                'curve': {'run_id': latest['id'], 'label': latest['label'], 'steps': curve} if latest else None,
-                'learnt': {'run_id': learnt_run['id'], 'label': learnt_run['label'], 'tasks': learnt} if learnt_run else None, 'timeline': timeline}
+                'curve': {'run_id': latest['id'], 'label': latest['label'], 'steps': curve} if latest else None, 'timeline': timeline}
 
 
 @router.get('/runs')
@@ -209,10 +206,38 @@ def run_detail(run_id: str, source: str = Source):
                 'job': one(con, 'SELECT * FROM jobs WHERE run_id = ?', run_id), 'method': method}
 
 
+OUTCOME_ORDER = "CASE t.outcome WHEN 'trained' THEN 0 WHEN 'eligible' THEN 1 WHEN 'needs controls' THEN 2 WHEN 'out of band' THEN 3 WHEN 'failed controls' THEN 4 WHEN 'excluded' THEN 5 ELSE 6 END"
+
+
 @router.get('/tasks')
-def tasks_list(source: str = Source):
+def tasks_list(source: str = Source, q: str | None = None, outcome: str | None = None, cats: str | None = None, collection: str | None = None,
+               limit: int = Query(100, ge=1, le=1000), offset: int = Query(0, ge=0)):
+    """Every task, filtered on the server: search, gate outcome, categories (comma-separated) and submission. Counts per outcome
+    ignore the outcome filter and counts per category ignore the category filter, so filter chips show what each choice would give.
+    For one submission, each trained task carries its pass rate early and late in the submission's latest run that recorded it."""
     with db(source) as con:
-        return rows(con, 'SELECT t.*, c.title AS collection_title, c.team FROM tasks t JOIN collections c ON c.id = t.collection_id ORDER BY c.title, t.name')
+        base, args = ['1 = 1'], []
+        if collection: base.append('t.collection_id = ?'); args.append(collection)
+        if q: base.append('(t.name LIKE ? OR c.title LIKE ? OR c.team LIKE ?)'); args += [f'%{q}%'] * 3
+        cat_list = [x for x in (cats or '').split(',') if x]
+        by_cat = (f"t.category IN ({','.join('?' * len(cat_list))})", cat_list) if cat_list else ('1 = 1', [])
+        by_out = ('t.outcome = ?', [outcome]) if outcome else ('1 = 1', [])
+        frm = 'FROM tasks t JOIN collections c ON c.id = t.collection_id WHERE ' + ' AND '.join(base)
+        counts_out = {r['outcome']: r['n'] for r in rows(con, f'SELECT t.outcome, COUNT(*) n {frm} AND {by_cat[0]} GROUP BY t.outcome', *args, *by_cat[1])}
+        counts_cat = {r['category']: r['n'] for r in rows(con, f'SELECT t.category, COUNT(*) n {frm} AND {by_out[0]} GROUP BY t.category', *args, *by_out[1])}
+        where = f'{frm} AND {by_cat[0]} AND {by_out[0]}'; wargs = [*args, *by_cat[1], *by_out[1]]
+        total = one(con, f'SELECT COUNT(*) n {where}', *wargs)['n']
+        out = rows(con, f'SELECT t.*, c.title AS collection_title, c.team {where} ORDER BY {OUTCOME_ORDER}, c.title, t.name LIMIT ? OFFSET ?', *wargs, limit, offset)
+        learnt = None
+        if collection:
+            run = one(con, 'SELECT r.id, r.label FROM runs r WHERE r.collection_id = ? AND EXISTS (SELECT 1 FROM run_task_stats s WHERE s.run_id = r.id) '
+                           'ORDER BY COALESCE(r.started_at, r.created_at) DESC LIMIT 1', collection)
+            if run:
+                stats = {x['name']: x for x in rows(con, 'SELECT name, start, finish FROM run_task_stats WHERE run_id = ?', run['id'])}
+                for t in out:
+                    if t['name'] in stats: t['start'], t['finish'] = stats[t['name']]['start'], stats[t['name']]['finish']
+                learnt = run
+        return {'total': total, 'rows': out, 'by_outcome': counts_out, 'by_category': counts_cat, 'learnt_run': learnt}
 
 
 @router.get('/leaderboard')

challenges.py

@@ -423,12 +423,21 @@ def eligibility(record):
     stored static report when it was computed under this policy, otherwise re-checked from the pinned source once per
     process (read-only, like the gate plan)."""
     static=(record.get('quality_gates') or {}).get('static') or {}
-    if not (static.get('version')==gates.VERSION and (static.get('policy') or {}).get('require_oracle')==gates.REQUIRE_ORACLE and 'excluded' in static):
-        key=(record['id'],record['revision'],gates.VERSION)
-        if key not in _eligibility: _eligibility[key]=gates.compact(pinned_static(record,gates.REQUIRE_ORACLE))
-        static=_eligibility[key]
+    if not static_current(static): static=static_report(record)
     return static['summary']['eligible'],static['summary']['tasks'],static['excluded'],static.get('needs_controls',[])
 
+def static_current(static):
+    return static.get('version')==gates.VERSION and (static.get('policy') or {}).get('require_oracle')==gates.REQUIRE_ORACLE and 'excluded' in static
+
+def static_report(record):
+    """The compact static-gate report of a record under the current policy: the stored one when it is current and lists
+    every task, otherwise recomputed from the pinned source once per process (read-only)."""
+    static=(record.get('quality_gates') or {}).get('static') or {}
+    if static_current(static) and 'task_identity' in static: return static
+    key=(record['id'],record['revision'],gates.VERSION)
+    if key not in _eligibility: _eligibility[key]=gates.compact(pinned_static(record,gates.REQUIRE_ORACLE))
+    return _eligibility[key]
+
 def mirror_check(row,source):
     """Whether the pinned submission can be mirrored for a run, from file listings only: nothing is copied."""
     client=hub();target=mirror_path(source['id'],source['revision'])

mock_data.py

@@ -89,41 +89,25 @@ DESCRIBE = {
 for _c, _extra in {'system-administration': ['Move a service to a new user without downtime', 'Find what keeps filling /tmp at 3 am', 'Repair a broken PAM stack from a rescue shell', 'Pin a kernel module that breaks on upgrade', 'Migrate crontabs to systemd timers'], 'debugging': ['Find the off-by-one in a pagination bug', 'Explain a memory spike after a config reload', 'Fix a deadlock between two worker pools', 'Find why a test passes alone but fails in the suite', 'Track down a timezone bug in nightly reports'], 'security': ['Find the SSRF in a small web service', 'Remove secrets committed to a repo’s history', 'Lock down a world-writable cron directory', 'Patch a path traversal in a file server', 'Find the weak JWT signing configuration'], 'software-engineering': ['Replace a hand-rolled argument parser', 'Add retries with backoff to a flaky client', 'Remove a circular import without behaviour change', 'Make a CLI’s JSON output stable across versions', 'Upgrade a library across a breaking API change'], 'data-processing': ['Parse a fixed-width mainframe export', 'Convert timestamps from five time zones to UTC', 'Fill gaps in a sensor series without inventing peaks', 'Split one giant XML file into valid records', 'Match customer records across two spellings'], 'file-operations': ['Recover files from a half-written zip', 'Rename 10,000 files from a CSV mapping', 'Find which files changed between two backups', 'Fix permissions on a copied home directory', 'Deduplicate a directory with hard links'], 'scientific-computing': ['Fix a unit mix-up in a simulation input', 'Make a Monte Carlo run reproducible', 'Port a MATLAB script to NumPy exactly', 'Interpolate missing values in a climate grid', 'Speed up a pairwise distance matrix'], 'data-science': ['Rebuild a dashboard number from raw events', 'Find duplicated users inflating a metric', 'Fit a model that respects a time split', 'Correct a biased sample with known weights', 'Find the join that fans out revenue'], 'machine-learning': ['Find the label leak in a feature pipeline', 'Match a paper’s reported accuracy', 'Fix a tokenizer mismatch at inference', 'Make evaluation deterministic across runs', 'Recover from a bad learning-rate schedule'], 'model-training': ['Fix a checkpoint that will not load on CPU', 'Find why loss plateaus after warmup', 'Shard a dataset for four workers evenly', 'Fix mixed precision that overflows', 'Resume a run with the right data order'], 'mathematics': ['Verify a closed form against brute force', 'Find integer solutions to a small system', 'Fix a rounding bug in a financial formula', 'Compute exact probabilities for a dice game', 'Prove two SQL queries return the same rows'], 'optimization': ['Remove an N+1 query from a report', 'Cache a slow API without stale reads', 'Cut a Docker image from 2 GB to 200 MB', 'Make a hot loop allocation-free', 'Reduce a cold start from 8 s to 2 s'], 'games': ['Solve a nonogram from its clue file', 'Finish a maze with limited moves', 'Win tic-tac-toe variants against a script', 'Complete a text puzzle box in 30 moves', 'Find the winning line in a Go problem'], 'tool-use': ['Batch-resize images with ImageMagick', 'Extract tables from a PDF with CLI tools', 'Sync two directories over rsync safely', 'Query a SQLite file for a weekly report', 'Script tmux to lay out a dev session']}.items(): TASKS[_c] += _extra
 
 SETTINGS = ['on Debian 12', 'on Alpine', 'in a Python 3.12 repo', 'in a Rust workspace', 'with only busybox', 'on a read-only root', 'in a Go monorepo',
-            'on Ubuntu 24.04', 'inside a container', 'on a 1 GB VM', 'with no network', 'in a Node 22 project']
+            'on Ubuntu 24.04', 'inside a container', 'on a 1 GB VM', 'with no network', 'in a Node 22 project', 'on Fedora 40', 'in a Java 21 service', 'under strict SELinux', 'in a PHP 8 app']
 _setting = iter(range(10 ** 6))
 _used = set()
 _uses = {}  # how often each title has been sampled, so collections draw the least-used titles first
 
 
-def sample_tasks(counts, band, excluded, controls_failed, k=10):
-    """k example tasks in the collection's category mix (no repeats), with outcomes in the same proportions as its funnel."""
-    total = sum(counts.values()); cats = sorted(counts, key=lambda c: -counts[c]); names = []
-    quota = {c: max(1, round(k * counts[c] / total)) for c in cats}
-    fresh = lambda c: sorted(TASKS[c], key=lambda t: (_uses.get(t, 0), trng.random()))  # least-used titles first
-    for c in cats:
-        for t in fresh(c)[:quota[c]]:
-            if len(names) < k: names.append((t, c))
-    for c in cats:  # top up from the largest categories when quotas round short
-        for t in fresh(c):
-            if len(names) < k and (t, c) not in names: names.append((t, c))
-    for t, _ in names: _uses[t] = _uses.get(t, 0) + 1
-    in_band = sum(band[1:BAND]); out_band = band[0] + band[BAND]
-    shares = [('excluded', excluded), ('failed controls', controls_failed), ('out of band', out_band), ('trained', in_band)]
-    plan = [st for st, n in shares for _ in range(round(k * n / max(1, total)))]
-    plan = (plan + ['trained'] * k)[:len(names)]; trng.shuffle(plan)
-    out = []
-    base = next(_setting)
-    for (title, c), st in zip(names, plan):
-        if title in _used:  # a title another collection already has gets its own setting
-            for shift in range(len(SETTINGS)):
-                full = f'{title}, {SETTINGS[(base + shift) % len(SETTINGS)]}'
-                if full not in _used: break
-            title = full
-        _used.add(title)
-        if st == 'excluded': out.append({'name': title, 'category': c, 'status': st, 'passes': None, 'why': trng.choice(['reference solution readable inside the sandbox', 'answer file baked into the image', 'verifier only checks that a file exists'])})
-        elif st == 'failed controls': out.append({'name': title, 'category': c, 'status': st, 'passes': None, 'why': trng.choice(['doing nothing passes the verifier', 'the reference solution fails 3 of 8 reruns'])})
-        elif st == 'out of band': kb = 0 if trng.random() < band[0] / max(1, out_band) else BAND; out.append({'name': title, 'category': c, 'status': st, 'passes': kb, 'why': 'never solved: no learning signal' if kb == 0 else 'always solved: no learning signal'})
-        else: out.append({'name': title, 'category': c, 'status': 'trained', 'passes': trng.choices(range(1, BAND), weights=[band[j] + 0.01 for j in range(1, BAND)])[0], 'why': None})
+def all_tasks(counts, band, excluded, controls_failed):
+    """Every task of a collection: categories in its mix, and outcomes exactly as its funnel counts them."""
+    cats = [c for c, k in counts.items() for _ in range(k)]; trng.shuffle(cats)
+    plan = ['excluded'] * excluded + ['failed controls'] * controls_failed + [k for k in range(BAND + 1) for _ in range(band[k])]
+    plan += ['excluded'] * (len(cats) - len(plan)); trng.shuffle(plan)
+    pools, out = {}, []
+    for i, (c, st) in enumerate(zip(cats, plan)):
+        pool = pools.setdefault(c, trng.sample([f'{t}, {where}' for t in TASKS[c] for where in SETTINGS], len(TASKS[c]) * len(SETTINGS)))
+        name = pool.pop() if pool else f'{trng.choice(TASKS[c])}, variant {i}'
+        if st == 'excluded': out.append({'name': name, 'category': c, 'status': st, 'passes': None, 'why': trng.choice(['the reference solution is copied into the sandbox', 'answer-like files are in the sandbox', 'the verifier only checks that files exist', 'the prompt overlaps a sealed held-out task'])})
+        elif st == 'failed controls': out.append({'name': name, 'category': c, 'status': st, 'passes': None, 'why': trng.choice(['doing nothing passes the verifier', 'the reference solution fails 3 of 8 reruns'])})
+        elif st in (0, BAND): out.append({'name': name, 'category': c, 'status': 'out of band', 'passes': st, 'why': 'never solved: no learning signal' if st == 0 else 'always solved: no learning signal'})
+        else: out.append({'name': name, 'category': c, 'status': 'trained', 'passes': st, 'why': None})
     return out
 
 
@@ -155,7 +139,7 @@ def collections():
                      'source_url': None, 'categories': counts,
                      'funnel': {'submitted': n, 'valid': n, 'static_eligible': valid, 'controls_passed': controls, 'in_band': trained, 'trained': trained},
                      'band': band, 'origin': {'original': round(n * rng.uniform(0.3, 0.8)), 'adapted': 0, 'generated': 0},
-                     'description': DESCRIBE[theme], 'tasks_preview': sample_tasks(counts, band, excluded, valid - controls),
+                     'description': DESCRIBE[theme], 'tasks': all_tasks(counts, band, excluded, valid - controls),
                      '_effect': round(effect, 2)})
         o = rows[-1]['origin']; rest = n - o['original']; o['adapted'] = round(rest * rng.uniform(0.3, 0.9)); o['generated'] = rest - o['adapted']
     return rows
@@ -252,7 +236,7 @@ def run_record(i, env, start, fate, now):
     order = ['setup', 'snapshot', 'baseline', 'gate', 'training', 'heldout', 'collect']; stages.sort(key=lambda s: order.index(s['key']))
     if metrics: next(s for s in stages if s['key'] == 'training')['training'] = {'metrics': metrics}
     task_stats = []  # per trained sample task: base passes (of 8), pass rate over the first and the last 4 steps (recipe v2 records this per task)
-    for tk in env.get('tasks_preview', []):
+    for tk in env.get('tasks', []):
         if tk['status'] != 'trained' or not metrics: continue
         first = clamp(tk['passes'] / BAND + trng.gauss(0, 0.06), 0, 1)
         last = clamp(first + (gain * 1.6 + trng.gauss(0, 0.12)) * min(1, len(metrics) / 32), 0, 1)
@@ -305,7 +289,7 @@ def schedule(envs, control_envs=()):
             age = (NOW - datetime.fromisoformat(r['ended_at'].replace('Z', '+00:00'))).total_seconds() / 3600
             r['verification'] = 'valid' if r.get('_control') else 'invalid' if rng.random() < 0.04 else 'valid' if age > rng.uniform(12, 36) else 'pending'
             env = next((e for e in envs if e['id'] == r['environment_id']), None) or next(e for e in control_envs if e['id'] == r['environment_id'])
-            bad = next((t['name'] for t in env.get('tasks_preview', []) if t['status'] == 'trained'), 'one trained task')
+            bad = next((t['name'] for t in env.get('tasks', []) if t['status'] == 'trained'), 'one trained task')
             r['verification_note'] = {'invalid': f'Rejected: the reference solution of “{bad}” was readable inside its sandbox, so the model could copy it (found in review). The task is excluded from future runs; this run does not count.',
                                       'valid': 'Organizer control; evidence reviewed.' if r.get('_control') else 'Evidence reviewed: held-out scores match the per-task results.', 'pending': None}[r['verification']]
     for r in runs: r.pop('_control', None)
@@ -412,7 +396,7 @@ def controls():
         env = {'id': f'env-control-{key}', 'title': title, 'repo_id': f'benchflow/pta-control-{key}', 'revision': '0' * 40, 'task_count': 120, 'author': 'organizers', 'team': 'organizers',
                'created_at': iso(OPEN - timedelta(days=5)), 'status': 'Validated', 'source_url': None, 'categories': mix, 'control': key, 'description': text,
                'funnel': {'submitted': 120, 'valid': 120, 'static_eligible': 120, 'controls_passed': 108, 'in_band': 60, 'trained': 60}, 'band': band,
-               'origin': {'original': 120, 'adapted': 0, 'generated': 0}, 'tasks_preview': [], '_effect': effect}
+               'origin': {'original': 120, 'adapted': 0, 'generated': 0}, 'tasks': all_tasks(mix, band, 0, 12), '_effect': effect}
         out_envs.append(env)
     return out_envs
 

store.py

@@ -43,7 +43,7 @@ CREATE TABLE board_meta(challenge_id TEXT PRIMARY KEY, per_run_sd_pp REAL, pendi
 CREATE TABLE jobs(id TEXT PRIMARY KEY, name TEXT, kind TEXT, purpose TEXT, detail TEXT, run_id TEXT, challenge_id TEXT, flavor TEXT, provider TEXT,
   stage TEXT, created_at TEXT, started_at TEXT, finished_at TEXT, seconds REAL, cost_usd REAL, url TEXT);
 CREATE TABLE known_issues(match TEXT, cause TEXT, fixed TEXT, blame TEXT);
-CREATE INDEX runs_collection ON runs(collection_id); CREATE INDEX runs_challenge ON runs(challenge_id);
+CREATE INDEX tasks_outcome ON tasks(outcome); CREATE INDEX runs_collection ON runs(collection_id); CREATE INDEX runs_challenge ON runs(challenge_id);
 CREATE INDEX stages_run ON run_stages(run_id); CREATE INDEX steps_run ON run_steps(run_id); CREATE INDEX tasks_collection ON tasks(collection_id);
 """
 
@@ -71,7 +71,7 @@ def load(path, payload, source, meta=None):
         for e in f.get('collections', []):
             ins('collections', (e['id'], e.get('title'), e.get('team') or e.get('author'), e.get('created_at'), e.get('description'), e.get('source_url'), e.get('task_count'),
                                 e.get('control'), j(e.get('categories')), j(e.get('funnel')), j(e.get('band')), j(e.get('origin')), e.get('status'), e.get('repo_id'), e.get('revision')))
-            for t in e.get('tasks_preview') or []: ins('tasks', (e['id'], t['name'], t.get('category'), t.get('status'), t.get('passes'), t.get('why')))
+            for t in e.get('tasks') or e.get('tasks_preview') or []: ins('tasks', (e['id'], t['name'], t.get('category'), t.get('status'), t.get('passes'), t.get('why')))
         for cid, m in metrics.items():
             for q in m.get('queued') or []: ins('queue', (cid, q.get('environment_id'), q.get('requested_at')))
             for r in m.get('runs') or []:
@@ -99,10 +99,42 @@ def load(path, payload, source, meta=None):
     return path
 
 
+# Static-gate finding codes (validation_gates.py) in plain words, for the task lists.
+CODE_TEXT = {'S-NO-ORACLE': 'no reference solution, so the oracle control cannot run', 'S-ORACLE-STUB': 'the reference solution does no work',
+             'L-ORACLE-NETWORK': 'the reference solution downloads from the network', 'L-ORACLE-IN-IMAGE': 'the reference solution is copied into the sandbox',
+             'L-VERIFIER-IN-IMAGE': 'verifier tests or expected outputs are copied into the sandbox', 'L-TEST-FILE-IN-IMAGE': 'test files in the sandbox may reveal expected outputs',
+             'L-ANSWER-FILE': 'answer-like files are in the sandbox', 'L-BUILD-CACHE': 'build caches or version history are in the sandbox', 'L-REMOTE-ADD': 'the image adds remote content',
+             'H-NO-ASSERTIONS': 'the verifier has no assertions', 'H-EXISTENCE-ONLY': 'the verifier only checks that files exist', 'L-GRADER-DATA-IN-IMAGE': 'grading data is readable in the sandbox',
+             'H-UNCONDITIONAL-REWARD': 'the verifier always gives reward 1', 'D-NAME-COLLISION': 'same name as a sealed held-out task', 'D-NGRAM-OVERLAP': 'the prompt overlaps a sealed held-out task'}
+
+
+def static_tasks(report):
+    """Every task of a collection with its static-gate outcome: excluded, needs controls (no working reference solution), or eligible."""
+    out = []
+    for name, ident in sorted((report.get('task_identity') or {}).items()):
+        excluded = (report.get('excluded') or {}).get(name)
+        codes = excluded or (report.get('tasks') or {}).get(name) or []
+        outcome = 'excluded' if excluded else 'needs controls' if name in (report.get('needs_controls') or []) else 'eligible'
+        why = '; '.join(dict.fromkeys(CODE_TEXT.get(c, c) for c in codes)) or None
+        out.append({'name': name, 'category': ident.get('category') or 'other', 'status': outcome, 'why': ('flagged: ' + why) if why and outcome == 'eligible' else why})
+    return out
+
+
 def live_payload():
     """The live arena in the loader's payload shape, from the Space's own read paths (HF datasets and HF Jobs)."""
     import challenges, compute_jobs
     formula = challenges.formula(); metrics, boards = {}, {}
+    records = {r.get('id'): r for r in challenges.collection_rows_cached()}
+    for c in formula.get('collections') or []:  # every task with its static-gate outcome, from the pinned revision (cached per revision)
+        try:
+            report = challenges.static_report(records[c['id']]); c['tasks'] = static_tasks(report)
+            if 'controls_passed' not in (c.get('funnel') or {}):  # static checks only: split out the tasks that still need their controls
+                c['funnel'] = {'submitted': report['summary']['tasks'], 'static_eligible': report['summary']['eligible'], 'needs_controls': len(report.get('needs_controls') or [])}
+            if not c.get('categories'):
+                cats = {}
+                for t in c['tasks']: cats[t['category']] = cats.get(t['category'], 0) + 1
+                c['categories'] = cats
+        except Exception: pass
     for c in challenges.CHALLENGES:
         try: metrics[c['id']] = challenges.metrics(c['id'])
         except Exception: metrics[c['id']] = {'runs': []}

test_compose.py

@@ -263,6 +263,25 @@ class AppDataTest(unittest.TestCase):
         compute = client.get('/api/app/compute?source=mock').json()
         self.assertEqual([q['position'] for q in compute['queue'] if q['challenge_id'] == 'terminal-35b'], list(range(1, len(data['metrics']['terminal-35b']['queued']) + 1)))
 
+    def test_every_task_is_listed_and_filtered_on_the_server(self):
+        from fastapi import FastAPI
+        from fastapi.testclient import TestClient
+        import app_api, store
+        client = TestClient((lambda a: (a.include_router(app_api.router), a)[1])(FastAPI()))
+        subs = client.get('/api/app/submissions?source=mock').json(); one = next(s for s in subs if not s['control'])
+        d = client.get(f"/api/app/tasks?source=mock&collection={one['id']}&limit=1000").json()
+        self.assertEqual(d['total'], one['task_count']); self.assertEqual(d['by_outcome'].get('trained'), one['funnel']['in_band'])
+        self.assertEqual(d['by_outcome'].get('excluded'), one['funnel']['submitted'] - one['funnel']['static_eligible'])
+        band = client.get(f"/api/app/tasks?source=mock&collection={one['id']}&outcome=trained").json()
+        self.assertTrue(band['rows'] and all(t['outcome'] == 'trained' for t in band['rows'])); self.assertEqual(band['by_outcome'], d['by_outcome'])
+        cat = next(iter(d['by_category'])); only = client.get(f"/api/app/tasks?source=mock&collection={one['id']}&cats={cat}").json()
+        self.assertEqual(only['total'], d['by_category'][cat])
+        # live: a static-gate report becomes one row per task, with codes in plain words
+        report = {'task_identity': {'a': {'category': 'debugging'}, 'b': {}, 'c': {'category': 'security'}}, 'excluded': {'b': ['L-ORACLE-IN-IMAGE']}, 'needs_controls': ['c'], 'tasks': {'a': ['H-EXISTENCE-ONLY']}}
+        rows = {t['name']: t for t in store.static_tasks(report)}
+        self.assertEqual((rows['a']['status'], rows['b']['status'], rows['c']['status']), ('eligible', 'excluded', 'needs controls'))
+        self.assertEqual(rows['b']['why'], 'the reference solution is copied into the sandbox'); self.assertTrue(rows['a']['why'].startswith('flagged: '))
+
     def test_live_database_is_loaded_from_the_live_payload(self):
         import store
         payload = {'formula': {'challenges': [{'id': 'tb2-9b', 'name': 'x', 'status': 'open'}], 'collections': [{'id': 'env-1', 'title': 'Pack', 'author': 'ada', 'task_count': 3}]},