Update frontend

Author: adelavega

autonima/webui/app.py

@@ -107,6 +107,7 @@ class PipelineRunRequest(BaseModel):
 
     class MetaRunRequest(BaseModel):
         output_folder: str
+        source_run_id: Optional[str] = None
         estimator: str = "mkdadensity"
         estimator_args: str = "{}"
         corrector: str = "fdr"
@@ -465,6 +466,7 @@ async def start_meta_run(project_id: str, payload: MetaRunRequest):
             metadata = run_manager.start_meta_run(
                 project=project,
                 output_folder=payload.output_folder,
+                source_run_id=payload.source_run_id,
                 estimator=payload.estimator,
                 estimator_args=payload.estimator_args,
                 corrector=payload.corrector,

autonima/webui/progress.py

@@ -272,11 +272,39 @@ def build_stage_status(
         parsing_data = _safe_read_json(outputs_dir / "coordinate_parsing_results.json")
         if parsing_data is not None:
             stages["parsing"]["status"] = "completed"
+            if isinstance(parsing_data, dict):
+                studies = parsing_data.get("studies", [])
+                analyses_count = 0
+                coordinates_count = 0
+                for study in studies if isinstance(studies, list) else []:
+                    analyses = study.get("analyses", []) if isinstance(study, dict) else []
+                    if not isinstance(analyses, list):
+                        continue
+                    analyses_count += len(analyses)
+                    for analysis in analyses:
+                        points = analysis.get("points", []) if isinstance(analysis, dict) else []
+                        if isinstance(points, list):
+                            coordinates_count += len(points)
+                counters["parsing"] = {
+                    "studies": len(studies) if isinstance(studies, list) else 0,
+                    "analyses": analyses_count,
+                    "coordinates": coordinates_count,
+                }
+            else:
+                counters["parsing"] = {"status": "Done"}
 
         annotation_data = _safe_read_json(outputs_dir / "annotation_results.json")
         if isinstance(annotation_data, list):
             stages["annotation"]["status"] = "completed"
-            counters["annotation"] = {"decisions": len(annotation_data)}
+            annotation_names = {
+                str(item.get("annotation_name", "")).strip()
+                for item in annotation_data
+                if isinstance(item, dict) and str(item.get("annotation_name", "")).strip()
+            }
+            counters["annotation"] = {
+                "decisions": len(annotation_data),
+                "annotations": len(annotation_names),
+            }
 
         final_data = _safe_read_json(outputs_dir / "final_results.json")
         if isinstance(final_data, dict):
@@ -290,6 +318,7 @@ def build_stage_status(
             if stages["parsing"]["status"] != "completed":
                 if not parsing_enabled:
                     stages["parsing"]["status"] = "completed"
+                    counters["parsing"] = {"status": "Off"}
                 elif run_status == "completed":
                     # The run reached final outputs; parsing did not produce a results file
                     # (e.g., no parseable tables). Treat this stage as complete rather than

autonima/webui/runs.py

@@ -127,27 +127,29 @@ def _maybe_create_execution_output(
         runtime_config_path: Path,
         resolved_output: Path,
         execution_mode: str,
+        cache_source_output: Optional[Path] = None,
     ) -> tuple[Path, Optional[str], Dict[str, Any]]:
         """Default UI behavior: branch to a new output when signatures changed."""
         if execution_mode != "auto_new_on_change":
             return resolved_output, None, {}
+        source_output = cache_source_output or resolved_output
         try:
             config = ConfigManager().load_from_file(runtime_config_path)
-            config.output.directory = str(resolved_output)
-            preview = preview_execution_changes(config, resolved_output)
+            config.output.directory = str(source_output)
+            preview = preview_execution_changes(config, source_output)
         except Exception:
             return resolved_output, None, {}
 
         if not preview.get("changed_stages"):
-            return resolved_output, None, preview
+            return source_output, None, preview
 
         execution_name = (
             time.strftime("%Y%m%d-%H%M%S")
             + "-"
             + str(preview.get("stage_hashes", {}).get("output", ""))[:8]
         )
         branched_output = resolved_output / "executions" / execution_name
-        return branched_output, str(resolved_output), preview
+        return branched_output, str(source_output), preview
 
     def _build_meta_command(
         self,
@@ -318,11 +320,20 @@ def start_pipeline_run(
         cache_preview: Dict[str, Any] = {}
         branched_from: Optional[str] = None
         if not output_folder:
+            previous_output_raw = str(project.get("last_output_folder") or "").strip()
+            previous_output = (
+                Path(previous_output_raw).expanduser().resolve()
+                if previous_output_raw
+                else None
+            )
+            if previous_output and not previous_output.exists():
+                previous_output = None
             resolved_output, branched_from, cache_preview = (
                 self._maybe_create_execution_output(
                     runtime_config_path,
                     resolved_output,
                     execution_mode,
+                    cache_source_output=previous_output,
                 )
             )
             if branched_from and not copy_valid_cache_from:
@@ -372,6 +383,7 @@ def start_meta_run(
         self,
         project: Dict[str, Any],
         output_folder: str,
+        source_run_id: Optional[str],
         estimator: str,
         estimator_args: str,
         corrector: str,
@@ -390,6 +402,8 @@ def start_meta_run(
             mode="meta",
             output_folder=output_path,
         )
+        metadata["source_run_id"] = source_run_id
+        metadata["source_output_folder"] = output_path
 
         cmd = self._build_meta_command(
             output_folder=output_path,
@@ -413,7 +427,7 @@ def start_meta_run(
             project["id"],
             {
                 "run_ids": run_ids,
-                "last_output_folder": output_path,
+                "last_meta_output_folder": output_path,
             },
         )