add manual recovery from failed CR

app.py

@@ -851,6 +851,90 @@ elif status in ("done", "error"):
             else:
                 st.warning("No TSs available yet — retry download or upload DOCX files above.")
 
+    # ── CR Recovery ───────────────────────────────────────────────────────────
+    failed_cr_path = output_dir / "failed_cr.json"
+    if failed_cr_path.exists():
+        failed_cr_entries = json.loads(failed_cr_path.read_text())
+        if failed_cr_entries:
+            st.divider()
+            st.subheader("⚠️ Recover failed CR downloads")
+            st.info(
+                f"{len(failed_cr_entries)} CR(s) could not be downloaded. "
+                "Retry or upload each one manually, then apply."
+            )
+
+            for entry in failed_cr_entries:
+                uid = entry["uid"]
+                cr_dir_path = Path(entry["cr_dir"])
+                expected = cr_dir_path / entry["expected_filename"]
+                ready = expected.exists() or (cr_dir_path / f"{uid}_extracted.docx").exists()
+                ts_label = (
+                    f"TS {entry['ts_spec_number']} v{entry['ts_version']}"
+                    if entry.get("ts_spec_number") else "TS unknown"
+                )
+                label = f"{'✅' if ready else '❌'}  CR {uid} → {ts_label}"
+                with st.expander(label, expanded=not ready):
+                    col1, col2 = st.columns(2)
+
+                    with col1:
+                        if st.button("🔄 Retry download", key=f"retry_cr_{uid}"):
+                            from fetch_crs import download_cr as _dl_cr
+                            with st.spinner(f"Downloading CR {uid}…"):
+                                fn, note = _dl_cr(
+                                    uid, cr_dir_path,
+                                    st.session_state.eol_user,
+                                    st.session_state.eol_password,
+                                )
+                            if fn:
+                                st.success(f"Downloaded: {fn.name}")
+                                st.rerun()
+                            else:
+                                st.error(f"Failed: {note}")
+
+                    with col2:
+                        uploaded_cr = st.file_uploader(
+                            f"Or upload `{entry['expected_filename']}`",
+                            type=["docx"],
+                            key=f"upload_cr_{uid}",
+                        )
+                        if uploaded_cr is not None:
+                            cr_dir_path.mkdir(parents=True, exist_ok=True)
+                            expected.write_bytes(uploaded_cr.read())
+                            st.success("Saved ✓")
+                            st.rerun()
+
+            ready_cr_entries = [
+                e for e in failed_cr_entries
+                if (Path(e["cr_dir"]) / e["expected_filename"]).exists()
+                or (Path(e["cr_dir"]) / f"{e['uid']}_extracted.docx").exists()
+            ]
+            remaining_cr = len(failed_cr_entries) - len(ready_cr_entries)
+
+            if ready_cr_entries:
+                if remaining_cr:
+                    st.warning(f"{len(ready_cr_entries)} ready, {remaining_cr} still missing.")
+                else:
+                    st.success(f"All {len(ready_cr_entries)} CR(s) ready.")
+
+                if st.button("▶ Apply recovered CRs", type="primary", key="apply_recovered_crs"):
+                    retry_log = str(session_dir(sid) / f"pipeline_{int(time.time())}_retry.log")
+                    cmd = [
+                        sys.executable,
+                        str(SCRIPTS_DIR / "orchestrate_cr.py"),
+                        "--output-dir", state["output_dir"],
+                        "--retry-mode",
+                    ]
+                    env = os.environ.copy()
+                    env["EOL_USER"]     = st.session_state.eol_user
+                    env["EOL_PASSWORD"] = st.session_state.eol_password
+                    _launch_proc(cmd, env, retry_log, sid, state, {
+                        "status":        "running",
+                        "log_path":      retry_log,
+                        "run_log_paths": state.get("run_log_paths", []) + [retry_log],
+                    })
+            else:
+                st.warning("No CRs recovered yet — retry download or upload DOCX files above.")
+
     # Navigation
     st.divider()
     col_restart, col_new = st.columns(2)

scripts/orchestrate_cr.py

@@ -345,6 +345,29 @@ def _run_steps_2_to_6(cr_list, ts_groups, output_dir, cr_dir, ts_dir,
         json.dumps(failed_ts_entries, indent=2)
     )
 
+    # Write failed_cr.json
+    failed_cr_entries = []
+    for uid, _ in cr_list:
+        if uid not in cr_paths:
+            sn, v = next(
+                ((sn, v) for (sn, v), uids in ts_groups.items() if uid in uids),
+                (None, None),
+            )
+            sc = sn.replace(' ', '') if sn else None
+            sd = spec_dirs.get((sn, v)) if sn else None
+            failed_cr_entries.append({
+                "uid":                  uid,
+                "cr_dir":               str(cr_dir),
+                "expected_filename":    f"{uid}.docx",
+                "ts_spec_number":       sn,
+                "ts_version":           v,
+                "ts_spec_dir":          str(sd) if sd else None,
+                "ts_expected_filename": f"ts_{sc}_v{v}.docx" if sc and v else None,
+            })
+    (output_dir / "failed_cr.json").write_text(json.dumps(failed_cr_entries, indent=2))
+    if failed_cr_entries:
+        print(f'  {len(failed_cr_entries)} failed CR download(s) written to failed_cr.json')
+
     # ── Steps 5 & 6: Apply CRs + Finalise each TS ────────────────────────────
     _section('Steps 5 & 6 — Applying CRs and Finalising Metadata')
     report = []  # (ts_key, n_ok, n_skip, n_crs, out_path, log_path, errors)
@@ -445,11 +468,11 @@ def main():
     # ── Retry mode — skip steps 1-4, reconstruct state from failed_ts.json ───
     if args.retry_mode:
         failed_ts_path = output_dir / 'failed_ts.json'
-        if not failed_ts_path.exists():
-            sys.exit('ERROR: failed_ts.json not found in output directory')
-        failed_ts_entries = json.loads(failed_ts_path.read_text())
-        if not failed_ts_entries:
-            print('No failed TSs in failed_ts.json — nothing to retry.')
+        failed_cr_path = output_dir / 'failed_cr.json'
+        failed_ts_entries = json.loads(failed_ts_path.read_text()) if failed_ts_path.exists() else []
+        failed_cr_entries = json.loads(failed_cr_path.read_text()) if failed_cr_path.exists() else []
+        if not failed_ts_entries and not failed_cr_entries:
+            print('No failed TSs or CRs — nothing to retry.')
             return
 
         _section('Retry mode — Steps 5 & 6 only')
@@ -482,6 +505,37 @@ def main():
                 elif plain.exists():
                     cr_paths[uid] = plain
 
+        # ── Recover CRs from failed_cr.json ──────────────────────────────────
+        still_failed_cr = []
+        for entry in failed_cr_entries:
+            uid = entry['uid']
+            cr_entry_dir = Path(entry['cr_dir'])
+            extracted = cr_entry_dir / f'{uid}_extracted.docx'
+            plain = cr_entry_dir / entry['expected_filename']
+            if extracted.exists():
+                cr_paths[uid] = extracted
+            elif plain.exists():
+                cr_paths[uid] = plain
+            else:
+                still_failed_cr.append(entry)
+                continue
+            sn, v = entry['ts_spec_number'], entry['ts_version']
+            if sn and v:
+                key = (sn, v)
+                ts_groups.setdefault(key, [])
+                if uid not in ts_groups[key]:
+                    ts_groups[key].append(uid)
+                if key not in spec_dirs and entry['ts_spec_dir']:
+                    spec_dirs[key] = Path(entry['ts_spec_dir'])
+                if key not in ts_paths and entry['ts_spec_dir'] and entry['ts_expected_filename']:
+                    ts_file = Path(entry['ts_spec_dir']) / entry['ts_expected_filename']
+                    if ts_file.exists():
+                        ts_paths[key] = ts_file
+                print(f'  [{uid}] CR recovered — will apply to TS {sn} v{v}')
+            else:
+                print(f'  [{uid}] CR recovered but TS group unknown — skipping apply')
+        failed_cr_path.write_text(json.dumps(still_failed_cr, indent=2))
+
         # ── Steps 5 & 6 (retry mode) ─────────────────────────────────────────
         report = []
 
@@ -505,7 +559,10 @@ def main():
         n_success = sum(1 for r in report if r[4] is not None and not r[6])
         n_partial  = sum(1 for r in report if r[4] is not None and r[6])
         n_failed   = sum(1 for r in report if r[4] is None)
+        n_cr_still = len(still_failed_cr)
         print(f'TSs processed:  {n_success} fully OK, {n_partial} with warnings, {n_failed} skipped/failed')
+        if n_cr_still:
+            print(f'CRs still missing: {n_cr_still} (see failed_cr.json)')
         _print_report(report, detailed=False)
         return