Diagnose evaluation failures and queue missing-cell recovery

README.md

@@ -15,9 +15,9 @@ Qwen3.5-2B training with Harbor multi-harness, native OpenCode, Harbor OpenCode-
 
 ## Latest update
 
-[September 16 evening: evaluation progress and GPU allocation](updates/2026-09-16-evening/REPORT.md) · [Figure](updates/2026-09-16-evening/eval-training-update.png)
+[September 16, 19:49 UTC: live eval progress and failure diagnosis](updates/2026-09-16-1950/REPORT.md). Includes recovery jobs, transport failures, and the measured OpenCode output-truncation regression.
 
-The dated update distinguishes accepted checkpoint scores from incomplete evaluations and records Harbor OpenCode-only training progress.
+[Earlier evaluation plot and GPU allocation update](updates/2026-09-16-evening/REPORT.md).
 
 ## Code and reproduction
 

updates/2026-09-16-1950/REPORT.md

@@ -0,0 +1,44 @@
+# Evaluation update and failure diagnosis
+
+Snapshot: **2026-09-16 19:49 UTC**. Qwen3.5-2B, 250 fixed tasks × four harnesses × pass@1. Scores below are not interchangeable with native SETA evaluation.
+
+| Run | Checkpoint | Graded | Current job | State |
+| --- | ---: | ---: | ---: | --- |
+| Harbor multi-harness | 900 | 973/1,000 | 81439 | Recovery queued; 27 missing |
+| Harbor multi-harness | 1,000 | 929/1,000 | 81441 | Recovery queued; 71 missing |
+| Harbor OpenCode-only | 100 | 21/1,000 | 81408 | Full evaluation running; smoke 8/8 TiTO passed |
+| Harbor OpenCode-only | 200 | 673/1,000 | 81406 | Full evaluation running; smoke 8/8 TiTO passed |
+
+Checkpoint 200 has three ungraded attempts so far, all confirmed Gradio HTTP 404s. Throughput is about 8.6 cells/minute: roughly 40 minutes to finish the first pass from this snapshot, plus retries and audit. Checkpoint 100 has just entered its full pass. Checkpoints 300 and 400 are saved and wait behind the current evaluation jobs.
+
+## What is failing
+
+The previous checkpoint-1,000 recovery job 81252 ended at **19:38 UTC** after six passes, with 929 graded cells. Checkpoint 900 stopped earlier with 973. Their Mini-SWE-Agent failures show Gradio's `No interface is running` response during model requests. Earlier Claude Code attempts include sandbox connection resets, HTTP 400s and 600-second agent timeouts; a timeout alone does not establish an infrastructure cause. The final pass also contains evaluator pause/skip records after repeated failures. These are not all independent task attempts.
+
+The tunnel watchdog continued reporting healthy because its short health requests passed. A fresh probe of the active checkpoint-200 tunnel passed 24/24 health requests; this does not validate long model streams. Engine metrics do not show memory exhaustion: checkpoint 1,000's maximum KV cache usage was 48.5%, median waiting requests zero, and maximum waiting requests three. This points away from GPU memory as the principal blocker.
+
+## A separate OpenCode behavior regression
+
+The older multi-harness model has a marked deterioration in its completed OpenCode arm:
+
+| Checkpoint | Correct / 250 | Observed OpenCode score | Final completion hit 4,096-token cap | Cap reached and no answer written |
+| --- | ---: | ---: | ---: | ---: |
+| 800 | 58 | 23.2% | 8 | 8 |
+| 900 | 6 | 2.4% | 225 | 225 |
+| 1,000 | 14 | 5.6% | 204 | 202 |
+
+These counts come from the first graded attempt for every task, its exact-token capture and retained verifier output. Example traces contain long prose and terminate with `finish_reason=length`; the verifier reports no `/workdir/answer.txt`. These zero rewards must remain in the result. Retrying missing infrastructure cells will not fix this score drop. The cause of the changed behavior is not established; it needs a controlled model/harness diagnostic. The 4,096-token limit and model parameters have not been changed for recovery. The full checkpoint-900/1,000 TiTO and harness-version acceptance gates remain outstanding, so their overall scores remain withheld.
+
+## Recovery actions
+
+Queued **81439 (900)** and **81441 (1,000)** on hopper-dev, each with one H100, TP1/DP1 and **concurrency 8**, up to three passes, retrying only ungraded cells. The lower concurrency is an operational recovery trial to reduce simultaneous model/transport activity, not a proven fix for Gradio. Model weights, test order, harness versions, sampling, 17-call budget, 600-second timeout and score selection are unchanged. All 973 and 929 graded results are preserved, including zeros; capture hashes are recorded before resuming.
+
+Both jobs wait on hopper-dev's two-running-job user quota, currently occupied by the two OpenCode-only evals. CPU collector **81443** will apply the original completeness, TiTO and harness-version gates and publish accepted results. The existing dashboard publisher remains active. No running trainer or evaluator was stopped; hopper-extra and hopper-atl were not used.
+
+## Training and accepted scores
+
+Harbor OpenCode-only trainer 81075 is running at **step 404**, with **checkpoint 400 saved**. Latest 50-step mean reward is **0.330**, versus **0.296** previously; recorded numerical scalars remain finite. This short increase does not establish held-out improvement.
+
+Accepted full evaluation scores are unchanged: Harbor multi-harness **37.0% at checkpoint 500** (best) and **27.0% at checkpoint 800** (latest); the separate native OpenCode run ends at **29.8% at checkpoint 1,000**. Harbor OpenCode-only has not yet completed its first full checkpoint evaluation.
+
+[Status and missing-cell inventory](status.json) · [OpenCode truncation evidence](opencode-truncation.json) · [Serving diagnostics](serving-diagnostics.json)

updates/2026-09-16-1950/inspect_evals.py

@@ -0,0 +1,103 @@
+"""Read-only evaluation inventory and failure diagnosis; never change score selection."""
+import json
+import math
+import statistics
+import subprocess
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+
+OUT = Path(__file__).resolve().parent
+ROOT = OUT.parent.parent
+BASE = ROOT / 'experiments/async_grpo_harbor_data_agent/logs'
+
+
+def slurm(job):
+    result = subprocess.check_output(['sacct', '-X', '-n', '-P', '-j', str(job), '--format=State,ExitCode'], text=True).strip().splitlines()
+    return result[0].split('|')[0] if result else 'UNKNOWN'
+
+
+def inspect(run, step, source_job):
+    output = BASE / run / f'checkpoint-evals/step-{step:06d}'
+    logs = output / f'job-{source_job}'
+    current = json.loads((output / 'submission.json').read_text())
+    config = json.loads((logs / 'traces/eval_config.json').read_text())
+    selected, latest = {}, {}
+    for file in sorted((logs / 'traces').glob('*.jsonl')):
+        for line in file.read_text().splitlines():
+            try:
+                row = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            key = (row['arm'], row['index'], row['rep'])
+            latest[key] = row
+            reward = row.get('reward')
+            if isinstance(reward, (int, float)) and math.isfinite(reward) and row.get('n_turns', 0) > 0:
+                selected.setdefault(key, row)
+    arm_stats = {}
+    errors = Counter()
+    missing = []
+    for arm in config['arms']:
+        rows = [r for k, r in selected.items() if k[0] == arm['name']]
+        arm_stats[arm['harness']] = {'graded': len(rows), 'correct': sum(r['reward'] for r in rows),
+                                   'pass_fraction_among_graded_only': sum(r['reward'] for r in rows) / len(rows) if rows else None}
+        for index in config['indices']:
+            key = (arm['name'], index, 0)
+            if key in selected:
+                continue
+            r = latest.get(key, {})
+            category = 'Not yet attempted'
+            text = r.get('error') or r.get('skip_reason') or ''
+            if r.get('skipped'):
+                category = 'Skipped after evaluator failure brake'
+            elif text:
+                category = 'Other rollout error'
+                root = Path(r['capture_file']).parents[2] if r.get('capture_file') else logs
+                trial = root / 'trials' / r.get('trial_name', '') / 'result.json'
+                if trial.exists():
+                    data = json.loads(trial.read_text())
+                    text += (data.get('exception_info') or {}).get('exception_message', '')
+                for marker, label in [('No interface is running', 'Gradio tunnel 404'),
+                                      ('connection reset', 'Sandbox/HTTP connection reset'),
+                                      ('Agent execution timed out', '600-second agent timeout; cause unresolved'),
+                                      ('Healthcheck failed', 'Sandbox data healthcheck failure'),
+                                      ('Invalid HTTP request', 'HTTP 400 invalid request')]:
+                    if marker in text:
+                        category = label
+                        break
+            errors[category] += 1
+            missing.append({'harness': arm['harness'], 'index': index, 'category': category})
+    tito_file = logs / 'smoke_tito.json'
+    tito = json.loads(tito_file.read_text()) if tito_file.exists() else {}
+    passes = sorted(logs.glob('eval-pass-*.log'))
+    return {'step': step, 'source_job': source_job, 'current_job': int(current['job_id']),
+            'state': slurm(current['job_id']), 'graded': len(selected), 'expected': 1000,
+            'harnesses': arm_stats, 'missing_categories': dict(errors), 'missing_cells': missing,
+            'full_evaluation_started': bool(passes), 'latest_pass': passes[-1].name if passes else None,
+            'smoke_passed': bool(tito.get('tito_pass') and len(tito.get('counts', {})) == 4 and all(n == 2 for n in tito['counts'].values())),
+            'accepted_full_checkpoint_score': None}
+
+
+def main():
+    status = {'checked_at': datetime.now(timezone.utc).isoformat(), 'runs': {}}
+    for run, key, step, source in [
+        ('multi4-long-prod-cont-20260915', 'multi4_900', 900, 81250),
+        ('multi4-long-prod-cont-20260915', 'multi4_1000', 1000, 81252),
+        ('harbor-opencode-only-20260916', 'harbor_opencode_100', 100, 81408),
+        ('harbor-opencode-only-20260916', 'harbor_opencode_200', 200, 81406)]:
+        status['runs'][key] = inspect(run, step, source)
+    snapshot = json.loads((ROOT / 'HuggingEnvs/04-data-agent/reports/async-comparison-20260916/snapshot.json').read_text())
+    train = snapshot['runs']['Harbor OpenCode-only']['training']
+    checkpoints = BASE / 'harbor-opencode-only-20260916/job-81075/run'
+    status['training'] = {'job': 81075, 'state': slurm(81075), 'step': train[-1]['step'],
+        'saved_checkpoint': max(int(p.name.split('-')[-1]) for p in checkpoints.glob('checkpoint-*') if p.is_dir()),
+        'metrics_updated_at': snapshot['updated_utc'],
+        'reward_latest50': statistics.mean(r['reward'] for r in train[-50:]),
+        'reward_previous50': statistics.mean(r['reward'] for r in train[-100:-50]),
+        'nonfinite_scalar_rows': sum(any(isinstance(r.get(k),(int,float)) and not math.isfinite(r[k]) for k in ['loss','grad_norm','ratio','kl']) for r in train)}
+    (OUT / 'status.json').write_text(json.dumps(status, indent=2) + '\n')
+    print(json.dumps({'checked_at': status['checked_at'], 'evals': {k:{f:v[f] for f in ['graded','current_job','state','smoke_passed','missing_categories']} for k,v in status['runs'].items()}, 'training':status['training']}, indent=2))
+
+
+if __name__ == '__main__':
+    main()

updates/2026-09-16-1950/opencode-truncation.json

@@ -0,0 +1,28 @@
+{
+  "metric": "First graded OpenCode rollout for each of the 250 fixed tasks; completed arm, full checkpoint audit still pending for 900/1000",
+  "checkpoints": {
+    "800": {
+      "graded": 250,
+      "correct": 58,
+      "final_completion_4096_tokens_finish_length": 8,
+      "missing_answer_file": 166,
+      "zero_reward_and_length_and_missing_answer": 8
+    },
+    "900": {
+      "graded": 250,
+      "correct": 6,
+      "final_completion_4096_tokens_finish_length": 225,
+      "missing_answer_file": 238,
+      "zero_reward_and_length_and_missing_answer": 225
+    },
+    "1000": {
+      "graded": 250,
+      "correct": 14,
+      "final_completion_4096_tokens_finish_length": 204,
+      "missing_answer_file": 219,
+      "zero_reward_and_length_and_missing_answer": 202
+    }
+  },
+  "method": "Read selected trace row, exact-token capture final turn, and verifier/test-stdout.txt from the capture source job. Graded zeros are preserved. No retry or score selection was performed.",
+  "interpretation": "Output truncation and missing answers explain many recorded OpenCode zeros. The cause of the behavior shift remains unproven; model/harness interaction requires a separate controlled diagnostic."
+}

updates/2026-09-16-1950/serving-diagnostics.json

@@ -0,0 +1,25 @@
+{
+  "checkpoint1000": {
+    "median_waiting_requests": 0,
+    "p95_waiting_requests": 1,
+    "max_waiting_requests": 3,
+    "max_kv_cache_usage": 0.4846686449060337,
+    "median_running_requests": 49,
+    "p95_running_requests": 61,
+    "max_running_requests": 69
+  },
+  "harbor_opencode_200": {
+    "median_waiting_requests": 0,
+    "p95_waiting_requests": 4,
+    "max_waiting_requests": 7,
+    "max_kv_cache_usage": 0.35697329376854603,
+    "median_running_requests": 41
+  },
+  "public_health_probe": {
+    "fresh_connections": 24,
+    "passed_identity_response": 24,
+    "concurrency": 2,
+    "max_latency_seconds": 0.6464883247390389
+  },
+  "interpretation": "No evidence of GPU memory exhaustion or a large inference queue. Passing health requests does not prove long-lived model requests are reliable."
+}