Detailed result view: readiness, family overview, grouped findings, episode explorer, JSON download

.gitignore

@@ -0,0 +1 @@
+.venv/

README.md

@@ -48,3 +48,30 @@ python app.py
 ```
 
 The numeric integration test uses a tiny local LeRobot recording with a declared camera and no media file. No production report is submitted by the tests.
+
+## Robotics Dataset Quality result
+
+The selected result expands into Training Readiness, Quality overview, Fix these
+first, Dataset overview, Episode explorer, and Technical details. Featured cards
+remain compact. The Space keeps using the bounded numeric worker and vendored
+converter; no grading policy, sidecar, video scope or publishing behavior changes.
+
+- Training Readiness displays the engine's readiness value (including undefined
+  values and their recorded reasons). Pass/review/blocked/unknown counts remain
+  the engine's decisions. Known blockers stay visible even with unknown episodes.
+- Family rows summarize computed results, unavailable checks and recorded finding
+  consequences. They are not 0–100 scores. Inventory completeness is shown for
+  structure; it is not a schema quality score. Diversity is not inferred from
+  assessment coverage, and absent published details are labeled “not provided.”
+- Issues are grouped by metric, source address, unit and consequence. Affected
+  episode counts are deduplicated within each group; warning counts count finding
+  records and may overlap blockers. Severity alone never creates a blocker.
+- Evidence and episode links expose recorded values, source coordinates and support.
+  Recorded skew never becomes a physical camera/action latency claim. Review
+  guidance is explicitly UI guidance, not an engine repair or causal diagnosis.
+- Download assessment JSON exports the current converted card (or stored summary
+  payload for a published lookup). This is not the complete raw CLI report:
+  metric examples and support intervals can be compacted by the existing converter.
+  Missing raw plots/thresholds require the full CLI report. Downloads expire with
+  Gradio's cache cleanup. Legacy published summaries retain their full-report link
+  and explicitly show when episode/diagnostic details are absent.

app.py

@@ -1,5 +1,7 @@
 """Kalanos HF Space: bounded numeric audits and published assessment examples."""
+import json
 import logging
+import tempfile
 import os
 from concurrent.futures import ThreadPoolExecutor
 from html import escape
@@ -90,7 +92,7 @@ def run(ref):
         # Always run fresh. Existing published reports never short-circuit grading.
         card = quick_grade(ref)
         payload = card_payload(card, KALANOS_API)
-        return _result(_one(render(payload, published=False)), payload['markdown'], _ok('Quick audit complete. Video: not assessed.'), card)
+        return _result(render(payload, published=False, detailed=True), payload['markdown'], _ok('Quick audit complete. Video: not assessed.'), card)
     except ValueError as exc:
         return _result('', '', _err(str(exc)), None)
     except Exception:
@@ -107,19 +109,29 @@ def lookup(ref):
         return _result('', '', _err(str(exc)), None)
     payload = published(ref)
     if payload:
-        return _result(_one(render(payload)), payload['markdown'], _ok('Stored assessment shown with its recorded date and scope. Grade dataset runs a fresh audit.'), None)
+        return _result(render(payload, detailed=True), payload['markdown'], _ok('Stored assessment shown with its recorded date and scope. Grade dataset runs a fresh audit.'), payload)
     if dataset_exists(ref) is False:
         return _result('', '', _err(NOT_FOUND.format(ref=ref)), None)
     return _result('', '', _err(f'No published report for {ref} on Kalanos Hub yet. Grade dataset runs a fresh quick audit.'), None)
 
 
+def download_assessment(card):
+    """Gradio serves this session's converted assessment and expires cached files."""
+    if card is None:
+        return gr.update(value=None, visible=False)
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', prefix='kalanos-assessment-', delete=False) as file:
+        json.dump(card, file, indent=2, ensure_ascii=False)
+    download.temp_files.add(file.name)
+    return gr.update(value=file.name, visible=True)
+
+
 # Publishing from the Space is intentionally disabled. The publisher upserts
 # reports by slug alone (hf/<org>/<name>), so a visitor's quick audit submitted
 # with a personal CLI key would replace the registry's full report for that
 # dataset. Re-enable once /api/reports scopes slug conflicts by tenant.
 # Until then: copy the HF card Markdown, or publish from the CLI.
 
-with gr.Blocks(title='Kalanos · Robotics Dataset Quality') as demo:
+with gr.Blocks(title='Kalanos · Robotics Dataset Quality', delete_cache=(600, 600)) as demo:
     gr.HTML(header(KALANOS_API))
     with gr.Column(elem_classes='k-grader'):
         gr.HTML(grader_intro())
@@ -129,8 +141,10 @@ with gr.Blocks(title='Kalanos · Robotics Dataset Quality') as demo:
             # Secondary action stays clear; report cards themselves use compact icons.
             lookup_btn = gr.Button('View published report', scale=1, elem_classes='k-secondary')
         status = gr.HTML('', elem_classes='k-status')
-    out = gr.HTML()
     report_state = gr.State(None, time_to_live=600)
+    download = gr.DownloadButton('Download assessment JSON (compact)', visible=False)
+    report_state.change(download_assessment, inputs=report_state, outputs=download)
+    out = gr.HTML()
     with gr.Accordion('HF card Markdown', open=False, elem_classes='k-accordion', visible=False) as card_acc:
         card_text = gr.Code(language='markdown', label='Copy into your existing dataset README', interactive=False)
     featured = gr.HTML(section('Featured dataset reports'))

cards.py

@@ -161,14 +161,16 @@ def card_payload(card, base):
     return dict(dataset=ref, revision=revision, assessed_at=card['graded_at'], report_id=card['report_id'],
                 requirements=d['scope']['requirements_id'], readiness=d['readiness']['score'],
                 counts=d['counts'], details=rows, markdown=markdown, notes=card.get('notes', []),
-                dataset_url='https://huggingface.co/datasets/' + quote(ref, safe='/'), report_url=None)
+                dataset_url='https://huggingface.co/datasets/' + quote(ref, safe='/'), report_url=None,
+                presentation=card.get('presentation'), dataset_metadata=card.get('dataset'),
+                readiness_detail=d['readiness'])
 
 
 def _status(c):
-    if not c.get('inventory_complete') or c.get('unknown') or not c.get('total'):
-        return 'incomplete', 'Incomplete evidence'
     if c.get('blocked'):
         return 'blocked', 'Blocking findings'
+    if not c.get('inventory_complete') or c.get('unknown') or not c.get('total'):
+        return 'incomplete', 'Incomplete evidence'
     if c.get('review'):
         return 'review', 'Review required'
     return 'pass', 'Pass within scope'
@@ -205,7 +207,7 @@ def _assessed(ts):
         return str(ts)
 
 
-def render(payload, published=True):
+def render(payload, published=True, detailed=False):
     c = payload['counts']
     score = payload['readiness']
     status, status_text = _status(c)
@@ -221,11 +223,33 @@ def render(payload, published=True):
     stats = ''.join(f'<div><strong>{v}</strong><span>{label}</span></div>' for v, label in [
         (c.get('total', '—'), 'Episodes assessed'), (f'{c.get("pass_count", 0)}/{c.get("total", 0)}', 'Eligible episodes'),
         (c.get('review', 0), 'Requiring review'), (c.get('blocked', 0), 'Blocked')])
+    stats_html = f'<div class="k-stats">{stats}</div>' if not detailed else ''
     kind = 'Published report' if published else 'Unpublished quick audit · video not assessed'
-    return (f'<article class="k-card"><span class="k-pill {status}">{status_text}</span><h3>{escape(name)}</h3>'
+    result = (f'<article class="k-card"><span class="k-pill {status}">{status_text}</span><h3>{escape(name)}</h3>'
             f'<div class="k-card-id">{escape(payload["dataset"])}</div>'
-            f'<div class="k-score"><span class="k-eyebrow">Technical readiness</span>{score_html}</div>'
-            f'<div class="k-stats">{stats}</div>{_bar(c)}'
+            f'<div class="k-score"><span class="k-eyebrow">Training Readiness</span>{score_html}</div>'
+            f'{stats_html}{_bar(c)}'
             f'<p class="k-note">{escape(_note(payload, status))}</p>'
             f'<div class="k-meta">{escape(payload["requirements"])}<br>Assessed {escape(_assessed(payload["assessed_at"]))}<br>{kind}</div>'
             f'<div class="k-actions">{actions}</div></article>')
+
+    if detailed:
+        from quality_card import render_detail
+        return render_detail(payload, result)
+    return result
+
+
+CSS += """
+.k-detail{background:#fff;border:1px solid var(--k-line);padding:24px;margin-bottom:16px}
+.k-detail-head{display:grid;grid-template-columns:minmax(260px,1fr) 1fr;gap:28px}
+.k-detail-head .k-card{border:0;padding:0}.k-detail-intro{padding:16px;background:var(--k-sage);align-self:start}
+.k-detail section{border-top:1px solid var(--k-line);margin-top:24px;padding-top:16px}
+.k-detail h3{font-size:21px;margin:0 0 12px}.k-detail h4{font-size:16px;margin:10px 0}
+.k-detail p{font-size:14px;line-height:1.6}.k-detail summary{cursor:pointer;padding:10px 0;font-weight:500}
+.k-detail details{border-bottom:1px solid var(--k-line)}.k-detail details:target{outline:2px solid var(--k-link);outline-offset:4px}
+.k-detail table{border-collapse:collapse;width:100%;font-size:13px}.k-detail th,.k-detail td{text-align:left;padding:12px 8px;border-bottom:1px solid var(--k-line)}
+.k-table-scroll{overflow-x:auto}.k-evidence{white-space:pre-wrap;overflow-wrap:anywhere;max-height:360px;overflow:auto;background:#f6f7f3;padding:12px;font-size:12px}
+.k-finding{border-left:3px solid var(--k-line);padding:12px 16px;margin:12px 0;background:#fafbf8}
+.k-finding a{display:inline-block;margin:4px 12px 4px 0}.k-detail :focus-visible{outline:3px solid #dc8437;outline-offset:3px}
+@media(max-width:760px){.k-detail{padding:16px}.k-detail-head{grid-template-columns:1fr;gap:12px}}
+"""

quality_card.py

@@ -0,0 +1,163 @@
+"""Detailed Space view over the existing public-engine presentation model.
+
+No policy thresholds, eligibility decisions, family scores or physical causes
+are inferred here. Missing presentation data remains explicitly unavailable.
+"""
+from collections import Counter
+from hashlib import sha256
+from html import escape
+import json
+
+from publisher_grader.presentation.action_model import LABELS
+
+
+TIMING_NOTE = ('Recorded timestamp skew or correspondence does not prove physical camera/action '
+               'latency. Capture alignment requires verified capture-clock evidence for both streams.')
+
+
+def text(value):
+    return escape(str(value if value is not None else 'Not recorded'))
+
+
+def evidence(value):
+    return '<pre class="k-evidence">' + text(json.dumps(value, indent=2, ensure_ascii=False)) + '</pre>'
+
+
+def findings(model):
+    """Keep source, unit and consequence separate; count unique episodes per issue."""
+    groups = {}
+    for episode in model.get('episodes') or []:
+        for finding in episode.get('findings') or []:
+            key = tuple(finding.get(k) for k in ('metric_id', 'node', 'source_field',
+                        'source_index', 'stream', 'instance', 'channel', 'subject_level', 'unit', 'consequence'))
+            group = groups.setdefault(key, {'finding': finding, 'episodes': set(), 'records': []})
+            group['episodes'].add(episode['id'])
+            group['records'].append({'episode': episode['id'], **finding})
+    ranks = {'block': 0, 'blocked': 0, 'review': 1, 'report_only': 2}
+    return sorted(groups.values(), key=lambda g: (ranks.get(g['finding'].get('consequence'), 3),
+                  -len(g['episodes']), str(g['finding'].get('metric_id'))))
+
+
+def family_rows(model):
+    """Diagnostic summaries, never derived readiness or universal diversity scores."""
+    all_findings = [f for e in model.get('episodes') or [] for f in e.get('findings') or []]
+    rows = []
+    for family, label in [('timing', 'Timing'), ('integrity', 'Signal integrity'),
+                          ('motion', 'Motion'), ('coverage', 'Coverage / diversity'),
+                          ('schema', 'Structure / schema')]:
+        metrics = [m for m in model.get('metrics') or [] if m['id'].startswith(family + '.')]
+        relevant = [f for f in all_findings if f.get('family') == family or
+                    str(f.get('metric_id', '')).startswith(family + '.')]
+        consequences = Counter(f.get('consequence') for f in relevant)
+        computed = sum((m.get('availability') or {}).get('computed', 0) for m in metrics)
+        gaps = sum(sum((m.get('availability') or {}).get(s, 0) for s in
+                       ('unavailable', 'skipped', 'error')) for m in metrics)
+        if consequences['block'] or consequences['blocked']:
+            status = 'BLOCKING FINDINGS'
+        elif consequences['review']:
+            status = 'REVIEW FINDINGS'
+        elif relevant:
+            status = 'OBSERVATIONS'
+        elif computed:
+            status = 'COMPUTED'
+        else:
+            status = 'NOT ASSESSED'
+        detail = f'{computed} computed metric results · {gaps} unavailable/skipped/error'
+        if relevant:
+            detail += f' · {len(relevant)} finding records'
+        if family == 'schema' and not metrics and not relevant:
+            inventory = model.get('inventory') or {}
+            status = ('INVENTORY COMPLETE' if inventory.get('complete') is True else
+                      'INVENTORY INCOMPLETE' if inventory.get('complete') is False else 'NOT PROVIDED')
+            detail = (f"{inventory.get('loaded', 'Unknown')} loaded / {inventory.get('expected', 'unknown')} expected episodes; "
+                      'inventory accounting is not a schema quality score')
+        elif 'metrics' not in model:
+            status, detail = 'NOT PROVIDED', 'Diagnostic details are absent from this payload'
+        rows.append((label, status, detail))
+    return rows
+
+
+def _issue(group, episode_links):
+    f = group['finding']
+    consequence = f.get('consequence') or 'unspecified'
+    style = {'block': 'blocked', 'blocked': 'blocked', 'review': 'review'}.get(consequence, 'incomplete')
+    metric = f.get('metric_id') or 'Unspecified metric'
+    name = LABELS.get(metric, metric.rsplit('.', 1)[-1].replace('_', ' ').capitalize())
+    source = f.get('source_field') or f.get('stream') or 'Source not resolved'
+    if f.get('source_index') is not None:
+        source += f"[{f['source_index']}]"
+    episodes = ' '.join(f'<a href="#{episode_links[e]}">{text(e.split("::")[-1])}</a>'
+                       for e in sorted(group['episodes']))
+    return (f'<article class="k-finding"><span class="k-pill {style}">{text(consequence.replace("_", " "))}</span>'
+            f'<h4>{text(name)}</h4><p>{text(source)} · {len(group["episodes"])} affected episode(s)</p>'
+            f'<p>Recorded example: {text(f.get("value"))} {text(f.get("unit") or "")} · {text(metric)}</p>'
+            '<details><summary>Evidence — recorded values and support</summary>'
+            + evidence(group['records']) + '</details>'
+            f'<details><summary>View {len(group["episodes"])} affected episode(s)</summary><p>{episodes}</p></details>'
+            '<details><summary>Review guidance</summary><p>Inspect the recorded source and support intervals. '
+            'Validate units, signal roles, clocks and task context before changing the data; rerun after confirmed corrections. '
+            'This is UI guidance, not an engine diagnosis or automatic repair.</p></details></article>')
+
+
+def render_detail(payload, summary):
+    model = payload.get('presentation') or {}
+    groups = findings(model)
+    prefix = 'quality-' + sha256(str((payload.get('dataset'), payload.get('report_id'))).encode()).hexdigest()[:12]
+    episode_links = {e['id']: f'{prefix}-episode-{i}' for i, e in enumerate(model.get('episodes') or [])}
+    blockers = [g for g in groups if g['finding'].get('consequence') in ('block', 'blocked')]
+    other = [g for g in groups if g not in blockers]
+    warnings = sum(f.get('severity') == 'warning' for e in model.get('episodes') or []
+                   for f in e.get('findings') or [])
+    count_note = (f'{len(blockers)} blocking issue group(s) · {warnings} warning finding record(s)'
+                  if 'episodes' in model else 'Detailed findings are unavailable in this assessment payload.')
+    readiness_reasons = (payload.get('readiness_detail') or model.get('readiness') or {}).get('reasons') or []
+    actions = f'<a class="k-btn" href="#{prefix}-blockers">View blockers ({len(blockers)})</a>' if blockers else ''
+    head = (f'<div class="k-detail-head">{summary}<div class="k-detail-intro"><span class="k-eyebrow">Assessment</span>'
+            f'<p>{text(count_note)}</p>'
+            + (f'<p>Readiness: {text("; ".join(readiness_reasons))}</p>' if readiness_reasons else '')
+            + '<p>Training Readiness is the engine’s technical quality result within the recorded scope. '
+            'It does not predict training success.</p><p>Diagnostic summaries below do not contribute new scores or change eligibility.</p>'
+            f'{actions}</div></div>')
+    rows = ''.join(f'<tr><th scope="row">{text(label)}</th><td>{text(state)}</td><td>{text(detail)}</td></tr>'
+                   for label, state, detail in family_rows(model))
+    quality = ('<section><h3>Quality overview</h3><p>Diagnostic families · no synthetic 0–100 scores. '
+               'Computed does not mean all checks passed. Coverage / diversity is distinct from assessment coverage.</p>'
+               f'<div class="k-table-scroll"><table><thead><tr><th>Family</th><th>Recorded summary</th><th>Evidence coverage</th></tr></thead><tbody>{rows}</tbody></table></div></section>')
+    issues = (f'<section><h3>Fix these first</h3><p>{text(TIMING_NOTE)}</p>'
+              '<p>Only recorded block/review consequences change eligibility; critical or warning severity alone does not.</p>'
+              f'<div id="{prefix}-blockers"><h4>Blocking findings</h4>'
+              + (''.join(_issue(g, episode_links) for g in blockers) if blockers else
+                 '<p>No blocking issue details recorded in this payload. Refer to the episode counts above.</p>') + '</div>')
+    if other:
+        issues += '<h4>Review and diagnostic findings</h4>' + ''.join(_issue(g, episode_links) for g in other[:3])
+        if len(other) > 3:
+            issues += f'<details><summary>Show {len(other)-3} additional issue groups</summary>' + ''.join(_issue(g, episode_links) for g in other[3:]) + '</details>'
+    gaps = [a for a in model.get('attention') or [] if a.get('category') in ('gap', 'inventory')]
+    if gaps:
+        issues += '<details><summary>Assessment gaps (not defect claims)</summary>' + ''.join(
+            f'<p><strong>{text(a.get("name"))}</strong> — {text(a.get("observation"))}</p>' for a in gaps) + '</details>'
+    issues += '</section>'
+    meta = payload.get('dataset_metadata') or {}
+    duration = model.get('duration')
+    known = model.get('durationKnown', 0)
+    dataset = (f'<section><h3>Dataset overview</h3><p>{text(payload["counts"].get("total"))} episodes assessed'
+               + (f' · {duration:g} recorded seconds ({known} episodes with duration)' if duration is not None else '')
+               + f'</p><p>Format: {text(meta.get("format"))} · Robot type: {text(meta.get("embodiment"))}</p>'
+               f'<p>Source fields: {text(", ".join(meta.get("sensors") or []) or None)}</p>'
+               '<p>Camera hardware count and arm DoF are not inferred from source fields.</p></section>')
+    explorer = '<section><h3>Episode explorer</h3>'
+    for e in model.get('episodes') or []:
+        explorer += (f'<details id="{episode_links[e["id"]]}"><summary>{text(e.get("label") or e["id"])} · '
+                     f'{text(e.get("status"))} · {len(e.get("findings") or [])} finding(s)</summary>'
+                     + evidence({k: e.get(k) for k in ('id', 'status', 'reasons', 'samples', 'duration', 'tasks', 'findings')}) + '</details>')
+    if not model.get('episodes'):
+        explorer += '<p>Episode details are not included. Open the published full report when available.</p>'
+    explorer += '</section>'
+    technical = ('<section><details><summary>Technical details</summary><p>Converted CLI assessment: metric summaries include up to three '
+                 'examples; support intervals may be truncated, with counts retained. Full raw metrics, plots and policy thresholds '
+                 'require the full CLI report when absent here.</p>'
+                 + evidence({'scope': model.get('scope'), 'readiness': payload.get('readiness_detail') or model.get('readiness'), 'assessment_coverage': model.get('coverage'),
+                             'inventory': model.get('inventory'), 'metrics': model.get('metrics'),
+                             'notes': (payload.get('notes') or []) + (model.get('notes') or [])})
+                 + '</details></section>')
+    return f'<div class="k-html k-detail">{head}{quality}{issues}{dataset}{explorer}{technical}</div>'

tests/test_quality_card.py

@@ -0,0 +1,101 @@
+import copy
+import json
+from pathlib import Path
+import unittest
+from unittest.mock import patch
+
+from cards import render
+from quality_card import family_rows, findings
+from app import download_assessment, download, lookup
+
+
+def payload():
+    finding = {'metric_id': 'timing.recorded_skew', 'family': 'timing',
+               'consequence': 'report_only', 'severity': 'critical', 'value': 180,
+               'unit': 'ms', 'source_field': 'action', 'node': 'n0',
+               'evidence': {'interpretation': 'recorded timestamps'},
+               'support': {'intervals': [{'start': 1, 'end': 3}]}}
+    return {'dataset': 'example/data', 'report_id': 'r', 'readiness': None,
+            'counts': {'total': 2, 'pass_count': 1, 'review': 0, 'blocked': 0,
+                       'unknown': 1, 'inventory_complete': False},
+            'requirements': 'numeric-core-v1', 'assessed_at': '2026-10-05T00:00:00Z',
+            'details': [], 'markdown': 'card', 'dataset_url': 'https://huggingface.co/datasets/example/data',
+            'presentation': {'episodes': [
+                {'id': 'e0', 'label': 'e0', 'status': 'pass', 'findings': [finding, copy.deepcopy(finding)]},
+                {'id': 'e1', 'label': 'e1', 'status': 'unknown', 'findings': [copy.deepcopy(finding)]}],
+                'metrics': [{'id': 'timing.recorded_skew', 'availability': {'computed': 3, 'unavailable': 1}}],
+                'readiness': {'score': None, 'reasons': ['inventory_incomplete']}}}
+
+
+class QualityCardTests(unittest.TestCase):
+    def test_report_only_critical_is_not_blocking(self):
+        p = payload()
+        self.assertEqual(family_rows(p['presentation'])[0][1], 'OBSERVATIONS')
+        html = render(p, detailed=True)
+        self.assertIn('0 blocking issue group(s)', html)
+        self.assertNotIn('View blockers (1)', html)
+        self.assertIn('Not established', html)
+        self.assertIn('inventory_incomplete', html)
+        self.assertIn('does not prove physical camera/action latency', html)
+        self.assertNotIn('GOOD', html)
+
+    def test_grouping_deduplicates_episodes_not_sources_or_consequences(self):
+        p = payload()
+        self.assertEqual(len(findings(p['presentation'])[0]['episodes']), 2)
+        f = copy.deepcopy(p['presentation']['episodes'][0]['findings'][0])
+        f['consequence'] = 'block'
+        p['presentation']['episodes'][0]['findings'].append(copy.deepcopy(f))
+        self.assertEqual(len(findings(p['presentation'])), 2)
+        self.assertEqual(family_rows(p['presentation'])[0][1], 'BLOCKING FINDINGS')
+        f['source_field'] = 'another_action'
+        p['presentation']['episodes'][0]['findings'].append(copy.deepcopy(f))
+        self.assertEqual(len(findings(p['presentation'])), 3)
+
+    def test_missing_published_detail_is_not_pass_or_unassessed(self):
+        p = payload()
+        del p['presentation']
+        html = render(p, detailed=True)
+        self.assertIn('NOT PROVIDED', html)
+        self.assertIn('Detailed findings are unavailable', html)
+        self.assertNotIn('0 blocking issue group(s)', html)
+        with patch('app.published', return_value=p):
+            self.assertEqual(lookup('example/data')[4], p)
+
+    def test_escaping_and_episode_links(self):
+        from html.parser import HTMLParser
+        class Links(HTMLParser):
+            def __init__(self):
+                super().__init__(); self.ids = set(); self.targets = set()
+            def handle_starttag(self, tag, attrs):
+                a = dict(attrs)
+                if 'id' in a: self.ids.add(a['id'])
+                if a.get('href', '').startswith('#'): self.targets.add(a['href'][1:])
+        p = payload()
+        p['presentation']['episodes'][0]['findings'][0]['source_field'] = '<script>bad()</script>'
+        html = render(p, detailed=True)
+        self.assertNotIn('<script>', html)
+        self.assertIn('&lt;script&gt;', html)
+        parsed = Links(); parsed.feed(html)
+        self.assertTrue(parsed.targets)
+        self.assertTrue(parsed.targets <= parsed.ids)
+
+    def test_blocked_status_remains_visible_with_unknown_episodes(self):
+        p = payload(); p['counts']['blocked'] = 1
+        self.assertIn('Blocking findings', render(p, detailed=True))
+        self.assertIn('1 unknown', render(p, detailed=True))
+
+    def test_download_roundtrip_and_reset(self):
+        p = payload()
+        update = download_assessment(p)
+        path = Path(update['value'])
+        try:
+            self.assertEqual(json.loads(path.read_text()), p)
+            self.assertIn(str(path), download.temp_files)
+            self.assertEqual(download_assessment(None)['visible'], False)
+            self.assertIsNone(download_assessment(None)['value'])
+        finally:
+            path.unlink(); download.temp_files.discard(str(path))
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_quick_grade.py

@@ -61,6 +61,11 @@ class QuickGradeTests(unittest.TestCase):
             payload=card_payload(card,'https://hub.kalanos.ai')
             self.assertIn('Unpublished quick audit', payload['markdown'])
             self.assertIn('aria-label="Preview and copy HF dataset card"',render(payload,False))
+            detailed = render(payload, False, detailed=True)
+            self.assertIn('INVENTORY COMPLETE', detailed)
+            self.assertIn('Training Readiness', detailed)
+            self.assertIn('Episode explorer', detailed)
+            self.assertIn('Video: not assessed', detailed)
             Path('/tmp/kalanos-quick-card.json').write_text(json.dumps(card))
 
 if __name__=='__main__':