Ai Research Explore Skill 安全审计

2062    eval_contract = eval_contract_payload(analysis_data, campaign, metric_policy)2063    baseline_gate: Dict[str, Any] = {"decision": "not-applicable", "reason": "Baseline gate was not evaluated."}2064    baseline_payload: Dict[str, Any] = {}2065    if not compatibility_mode:2066        baseline_gate, baseline_payload, _baseline_runtime = run_baseline_evaluation(2067            train_execute_script=train_execute_script,2068            run_execute_script=run_execute_script,2069            repo_path=workspace_repo_path,2070            current_research=current_research,2071            evaluation_source=campaign["evaluation_source"],2072            baseline_gate_cfg=campaign["baseline_gate"],2073            runtime_root=runtime_root,2074            model_profile_json=args.model_profile_json,2075            required_model_capabilities=args.require_model_capability,2076            gpu_monitor_enabled=not args.no_gpu_monitor,2077        )2078        baseline_gate = compare_baseline_to_sota(

1066    else:1067        run_args = [1068                "--repo",1069                str(repo_path),1070                "--command",1071                command,1072                "--timeout",1073                str(int(baseline_gate_cfg.get("timeout") or 60)),1074                "--runtime-root",1075                str(runtime_root),1076            ]1077        payload = run_json(run_execute_script, add_model_profile_args(run_args, model_profile_json, required_model_capabilities))1078        payload.setdefault("stop_reason", "command_completed" if payload.get("status") == "success" else "command_checked")1079    runtime_seconds = round(time.perf_counter() - start, 3)

1987    parser.add_argument("--include-setup-pass", action="store_true", help="Include env-and-assets-bootstrap in the planned chain.")1988    parser.add_argument("--run-selected-variants", action="store_true", help="Execute a small number of exploratory variants through the trusted execution helpers.")1989    parser.add_argument("--max-executed-variants", type=int, default=None, help="Maximum number of exploratory variants to execute when execution is enabled.")1990    parser.add_argument("--variant-timeout", type=int, default=None, help="Timeout in seconds for each executed exploratory variant.")1991    args = parser.parse_args()

344) -> Dict[str, Any]:345    if variant_spec.get("base_command") or not evaluation_source.get("command"):346        return variant_spec347348    normalized = dict(variant_spec)349    normalized["base_command"] = str(evaluation_source["command"]).strip()350    normalized["base_command_source"] = "evaluation_source"351    if evaluation_source.get("primary_metric") and not normalized.get("primary_metric"):

2064    baseline_payload: Dict[str, Any] = {}2065    if not compatibility_mode:2066        baseline_gate, baseline_payload, _baseline_runtime = run_baseline_evaluation(2067            train_execute_script=train_execute_script,2068            run_execute_script=run_execute_script,2069            repo_path=workspace_repo_path,2070            current_research=current_research,2071            evaluation_source=campaign["evaluation_source"],2072            baseline_gate_cfg=campaign["baseline_gate"],2073            runtime_root=runtime_root,2074            model_profile_json=args.model_profile_json,2075            required_model_capabilities=args.require_model_capability,2076            gpu_monitor_enabled=not args.no_gpu_monitor,2077        )2078        baseline_gate = compare_baseline_to_sota(

305        parser.error(f"model profile is missing required capabilities: {', '.join(missing)}")306    execution = execute_command(307        repo,308        args.command,309        args.timeout,310        args.shell_mode,311        runtime_root,312        model_adapter,313        args.monitor_gpu,314    )315    metric_data = parse_metrics(combine_logs([execution.get("stdout", ""), execution.get("stderr", "")]))

302303def constructor_probe_check(repo_path: Path, target_location_map: Sequence[Dict[str, Any]]) -> Dict[str, Any]:304    targets = safe_runtime_targets(target_location_map)305    if not targets:306        return {307            "name": "constructor-probe",308            "status": "passed",309            "passed": [],310            "blockers": [],311            "notes": ["constructor-probe-not-applicable"],312        }313    passed: List[str] = []314    blockers: List[str] = []315    soft_notes: List[str] = []316    sys_path_added = False317    repo_root = str(repo_path)318    if repo_root not in sys.path:319        sys.path.insert(0, repo_root)320        sys_path_added = True321    try:322        for item in targets:323            rel = str(item.get("file") or "")324            target_symbol = str(item.get("target_symbol") or "")325            symbol_root = target_symbol326            if ":" in symbol_root:327                symbol_root = symbol_root.split(":", 1)[1]328            symbol_root = symbol_root.split(".", 1)[0].strip()329            if not symbol_root or symbol_root == "unspecified-symbol":330                soft_notes.append(f"unresolved-target-symbol:{rel}")331                continue332            module_path = repo_path / rel333            module_name = f"_research_explore_ctor_{hashlib.sha1(rel.encode('utf-8')).hexdigest()[:12]}"334            try:335                spec = importlib.util.spec_from_file_location(module_name, module_path)336                if spec is None or spec.loader is None:337                    blockers.append(f"constructor-spec:{rel}")338                    continue339                module = importlib.util.module_from_spec(spec)340                exec_module_silenced(spec, module)341                if hasattr(module, symbol_root):

23362337    feasibility_bundle = run_execution_feasibility_pass(2338        analysis_output_dir=analysis_output_dir,2339        repo_path=workspace_repo_path,2340        campaign=campaign,2341        analysis_data=analysis_data,2342        variant_matrix=variant_matrix,2343        source_mapping=source_mapping,2344        executed_runs=executed_runs,2345    )2346    helper_stage_trace.append(build_stage_trace_entry("smoke-validation", "ai-research-explore/passes/execution_feasibility.py", f"Smoke report status: `{feasibility_bundle.get('smoke_report', {}).get('status', 'unknown')}`."))

514    ]515    runtime_checks = [516        import_probe_check(repo_path, source_mapping.get("target_location_map", [])),517        constructor_probe_check(repo_path, source_mapping.get("target_location_map", [])),518        short_run_check(executed_runs, variant_matrix),519    ]520    static_smoke = summarize_smoke(

9495def collect_candidate_edit_targets(repo: Path, current_research: str, task_family: str) -> List[str]:96    tokens = focus_tokens(current_research, task_family)97    scored: List[tuple[int, str]] = []98    for path in repo.rglob("*"):99        if path.is_dir():100            continue101        if any(part in SKIP_PARTS for part in path.relative_to(repo).parts):102            continue103        if path.suffix.lower() not in CODE_SUFFIXES:104            continue105        rel = path.relative_to(repo).as_posix()106        score = score_path(rel, task_family, tokens)107        if score:108            scored.append((score, rel))109110    scored.sort(key=lambda item: (-item[0], item[1]))111    return [rel for _, rel in scored[:8]]112

258    blockers: List[str] = []259    sys_path_added = False260    repo_root = str(repo_path)261    if repo_root not in sys.path:262        sys.path.insert(0, repo_root)263        sys_path_added = True264    try:265        for item in targets:266            rel = str(item.get("file") or "")267            module_path = repo_path / rel268            if not module_path.exists():269                blockers.append(f"missing:{rel}")270                continue271            module_name = f"_research_explore_smoke_{hashlib.sha1(rel.encode('utf-8')).hexdigest()[:12]}"272            try:273                spec = importlib.util.spec_from_file_location(module_name, module_path)274                if spec is None or spec.loader is None:275                    blockers.append(f"import-spec:{rel}")276                    continue277                module = importlib.util.module_from_spec(spec)278                exec_module_silenced(spec, module)279                passed.append(rel)280            except ModuleNotFoundError as exc:

2160    code_plan = initial_code_plan2161    feasibility_bundle = run_execution_feasibility_pass(2162        analysis_output_dir=analysis_output_dir,2163        repo_path=workspace_repo_path,2164        campaign=campaign,2165        analysis_data=analysis_data,2166        variant_matrix=variant_matrix,2167        source_mapping=source_mapping,2168        executed_runs=[],2169    )2170    helper_stage_trace.append(build_stage_trace_entry("execution-feasibility", "ai-research-explore/passes/execution_feasibility.py", f"Short-run feasibility: `{feasibility_bundle.get('feasibility', {}).get('short_run_feasibility', 'unknown')}`."))

172`agent.controller_status` 表示控制状态，`agent.task_outcome` 表示任务结果。173命令可增加上述 `verification` 验收产物与 JSON 数值指标；退出码为 0 但产物缺失、174指标超出容差，仍不能通过最终验收。验收条件由任务文件预先审核，模型不能修改。175这些检查不单独保证产物新鲜度或科研可比性；需要时使用全新目标工作目录。

2223def run_command(command: List[str], *, cwd: Path, dry_run: bool) -> None:24    print(f"+ {format_command(command)}")25    if dry_run:26        return27    subprocess.run(command, cwd=cwd, check=True)28

5960def install_with_manager(manager: str, env_name: str, repo_path: Path, rel_env_file: Optional[str], *, dry_run: bool) -> None:61    if rel_env_file == "requirements.txt":62        run_command(63            [manager, "run", "-n", env_name, "python", "-m", "pip", "install", "-r", rel_env_file],64            cwd=repo_path,65            dry_run=dry_run,66        )67    elif rel_env_file in {"pyproject.toml", "setup.py"}:68        run_command(69            [manager, "run", "-n", env_name, "python", "-m", "pip", "install", "-e", "."],70            cwd=repo_path,71            dry_run=dry_run,72        )73

113114    if env_file and env_file.name in CONDA_ENV_FILES:115        if manager is None:116            raise SystemExit("A conda-compatible manager is required for environment.yml-based setup. Install conda or mamba first.")117118        create_command = [manager, "env", "create", "-f", rel_env_file]119        if not declared_env_name:120            create_command.extend(["-n", resolved_env_name])121        run_command(create_command, cwd=repo_path, dry_run=args.dry_run)122        print_activation_instructions(declared_env_name or resolved_env_name, using_conda=True)

415416def _fits(request: Dict[str, int], available: Dict[str, int]) -> bool:417    return all(request[key] <= available[key] for key in ("cpu_slots", "gpu_slots", "memory_mib"))418

516517        scheduler_id = lease.lease_id518        store.state["scheduler"] = {519            "status": "running",520            "scheduler_id": scheduler_id,521            "pid": os.getpid(),522            "started_at": utc_now(),523            "heartbeat_at": utc_now(),524            "max_workers": max_workers,525            "resource_budget": totals,526            "resource_semantics": "request-based-admission-not-os-enforcement",527            "fail_fast": fail_fast,528        }

618                            continue619                        for key in available:620                            available[key] -= request[key]621                        job["runtime_run_id"] = new_run_id()622                        store.transition(job, "running", started_at=utc_now())623                        futures[executor.submit(_execute_job, dict(job))] = job624                        peak_running_jobs = max(peak_running_jobs, len(futures))625                        launched = True

507        for job in store.jobs():508            if job["status"] == "queued" and not _fits(job["resource_request"], totals):509                store.transition(510                    job,511                    "blocked",512                    "resource-request-exceeds-budget",513                    finished_at=utc_now(),514                    scheduler_budget=totals,515                )516

517        scheduler_id = lease.lease_id518        store.state["scheduler"] = {519            "status": "running",520            "scheduler_id": scheduler_id,521            "pid": os.getpid(),522            "started_at": utc_now(),523            "heartbeat_at": utc_now(),524            "max_workers": max_workers,525            "resource_budget": totals,526            "resource_semantics": "request-based-admission-not-os-enforcement",527            "fail_fast": fail_fast,528        }

496        creationflags = subprocess.CREATE_NEW_PROCESS_GROUP if os.name == "nt" else 0497        process = subprocess.Popen(498            argv,499            env=environment,500            cwd=repo,501            stdout=subprocess.PIPE,502            stderr=subprocess.PIPE,503            text=True,504            encoding="utf-8",505            errors="replace",506            bufsize=1,507            creationflags=creationflags,508            start_new_session=os.name != "nt",509        )510    except (FileNotFoundError, ShellSyntaxRequired, OSError, ValueError) as exc:

4041def lessons_home() -> Path:42    root = os.environ.get("RIGORPILOT_HOME")43    return Path(root).expanduser() if root else Path.home() / ".rigorpilot"444546def lessons_enabled() -> bool:47    return os.environ.get("RIGORPILOT_LESSONS", "1") != "0"484950def lessons_path() -> Path:51    return lessons_home() / "lessons.jsonl"525354def overlay_path() -> Path:55    return lessons_home() / "PERSONAL_RIGOR.md"56

61    try:62        if status in {"partial", "blocked"}:63            path = store.record_lesson(64                kind="failure-fix",65                skill="ai-research-reproduction",66                summary=f"[{status}] {context.get('main_blocker', 'unrecorded blocker')}",67                detail=str(context.get("documented_command") or ""),68                fingerprint=fingerprint,69            )70            return str(path) if path else None

124    }125    path = lessons_path()126    path.parent.mkdir(parents=True, exist_ok=True)127    with path.open("a", encoding="utf-8") as handle:128        handle.write(json.dumps(entry, ensure_ascii=False) + "\n")129    return path130

5354def maybe_record_lesson(repo_path: Path, context: Dict[str, Any]) -> Optional[str]:55    """Record failure blockers and later resolutions per the continuous-learning policy."""56    store = load_lessons_store()57    if store is None or not store.lessons_enabled():58        return None59    fingerprint = store.repo_fingerprint(repo_path)60    status = context.get("status")61    try:62        if status in {"partial", "blocked"}:63            path = store.record_lesson(64                kind="failure-fix",65                skill="ai-research-reproduction",66                summary=f"[{status}] {context.get('main_blocker', 'unrecorded blocker')}",67                detail=str(context.get("documented_command") or ""),68                fingerprint=fingerprint,69            )70            return str(path) if path else None71        if status == "success":

117  details.118- Load `../ai-research-reproduction/references/research-thinking-loop.md` before proposing or ranking candidate changes; it is the required greedy observe-ground-design-compare cycle.119- Load `../ai-research-reproduction/references/research-rigor-principles.md` before making novelty, contribution, SOTA, or comparability statements.120- Consult `~/.rigorpilot/PERSONAL_RIGOR.md` if present, under `../ai-research-reproduction/references/continuous-learning-policy.md` (advisory only; core wins).121- Load `../ai-research-reproduction/references/deep-learning-experiment-principles.md` when training,

234            break235    if locator_info:236        optional_record = resolve_optional_record(locator_info, lookup_config)237        resolved = optional_record or {}238        if not resolved:239            provider_type = locator_info.get("provider_type")240            if provider_type == "github":241                resolved = resolve_github_record(locator_info)242            elif provider_type == "arxiv":243                resolved = resolve_arxiv_record(locator_info)244            elif provider_type == "doi":245                resolved = resolve_doi_record(locator_info)246            elif provider_type == "url":247                resolved = resolve_url_record(locator_info)248            else:

138139def parse_generic_url(locator: str) -> Optional[Dict[str, Any]]:140    text = canonicalize_url(locator)141    if not HTTP_URL_RE.match(text):142        return None143    parsed = urllib.parse.urlsplit(text)144    return {145        "provider_type": "url",146        "source_type": "web",147        "locator_type": "url",148        "raw_locator": str(locator or "").strip(),149        "normalized_id": f"url:{text}",150        "identifier": text,151        "host": parsed.netloc.lower(),152        "url": text,153    }154

68        readme_meta = _fetch_readme(owner, repo)69        return {70            **record,71            "title": str(payload.get("full_name") or record["title"]),72            "summary": str(payload.get("description") or ""),73            "url": str(payload.get("html_url") or record["url"]),74            "repo_full_name": str(payload.get("full_name") or repo_full_name),75            "parse_status": "resolved",76            "fetch_status": "network-fetched",77            "evidence_class": "external_provider",78            "provider_metadata": {

83        locators = _extract_locators(text)84        relative_path = path.relative_to(repo_root).as_posix()85        for locator in locators:86            if locator in seen_locators:87                continue88            seen_locators.add(locator)89            seeds.append(90                {91                    "kind": _classify_kind(locator),92                    "title": locator,93                    "summary": f"Repo-local extracted source from `{relative_path}`.",94                    "query": locator,95                    "source_url": locator if locator.lower().startswith("http") else "",96                    "source_repo": "",97                    "source_file": "",98                    "source_symbol": "",99                    "origin": "repo_local_extracted",100                    "raw_locator": locator,101                    "extracted_from_repo_paths": [relative_path],102                }

72            "summary": str(payload.get("description") or ""),73            "url": str(payload.get("html_url") or record["url"]),74            "repo_full_name": str(payload.get("full_name") or repo_full_name),75            "parse_status": "resolved",76            "fetch_status": "network-fetched",77            "evidence_class": "external_provider",78            "provider_metadata": {

124125The standard README bundle is accompanied by `agent_state.json` (task/model126identity, messages, plan, pending calls, results), `trajectory.jsonl` (requests,127responses, public reasons, tools and usage), and `_runtime/` process evidence.128The verifier requires all `required_commands` to pass their exit/stdout and any

160gateway token accounting may differ. Output size is checked between actions,161not an OS disk quota. `CANCEL` is checked between actions; use the runtime CANCEL162file to stop an active process. Credentials are not included in provider errors.163Do not publish traces from private repositories without reviewing their contents.164

221222    worktree_root = experiment_worktree_root(git_root, experiment_branch)223    if worktree_root.exists():224        worktree_info = validate_existing_worktree(worktree_root, experiment_branch)225    else:226        worktree_root.parent.mkdir(parents=True, exist_ok=True)227        if branch_exists:228            run_text(["git", "worktree", "add", str(worktree_root), experiment_branch], cwd=git_root)229        else:230            run_text(["git", "worktree", "add", "-b", experiment_branch, str(worktree_root), head_sha], cwd=git_root)231            created_branch = True232        branch_sha = run_text(["git", "rev-parse", "--verify", branch_ref], cwd=git_root)233        worktree_info = validate_existing_worktree(worktree_root, experiment_branch)

20182019    durable_current_research = validate_current_research(repo_path, current_research)2020    experiment_branch = choose_experiment_branch(current_research, args.experiment_branch)2021    workspace_info = ensure_experiment_workspace(repo_path, experiment_branch)2022    context_id = build_context_id(current_research, experiment_branch)2023    workspace_repo_path = Path(workspace_info["workspace_root"]).resolve()20242025    helper_stage_trace = [2026        build_stage_trace_entry("validate-current-research", "ai-research-explore/validate_current_research", f"Validated durable current research `{current_research}` as `{durable_current_research['kind']}`."),2027        build_stage_trace_entry("workspace", "ai-research-explore/ensure_experiment_workspace", f"{'Created' if workspace_info['created_branch'] else 'Validated'} isolated {workspace_info['mode']} for branch `{experiment_branch}` at `{workspace_info['workspace_root']}`."),2028    ]20292030    scan_data = run_json(scan_script, ["--repo", str(workspace_repo_path), "--json"])2031    helper_stage_trace.append(build_stage_trace_entry("repo-scan", "repo-intake-and-plan/scripts/scan_repo.py", f"Scanned repository structure and README signals for `{repo_path.name}`."))

188189The bundle retains `readme_delivery.json` to identify its generated copy.190Repeating with the same source and output may refresh an unchanged owned copy.191An unrelated or edited file, symlink, hard link, or conflicting receipt is not192overwritten. Keep the receipt with the evidence; do not use it to claim that193source code or external media were verified. The original README remains intact.194

1213def resolve_url_record(locator_info: Dict[str, Any]) -> Dict[str, Any]:14    url = canonicalize_url(locator_info.get("url") or locator_info.get("raw_locator") or "")15    parsed = urllib.parse.urlsplit(url) if url else None16    record = {17        "provider_type": "url",18        "source_type": "web",19        "locator_type": locator_info.get("locator_type", "url"),20        "raw_locator": locator_info.get("raw_locator", ""),21        "normalized_id": locator_info.get("normalized_id", f"url:{url}" if url else ""),22        "title": url,23        "url": url,24        "authors": [],25        "year": None,26        "venue": parsed.netloc if parsed else "",27        "repo_full_name": "",28        "doi": "",29        "arxiv_id": "",30        "parse_status": "parsed-only",31        "fetch_status": "parsed-only",32        "evidence_class": "parsed_locator",33        "provider_metadata": {"resolved_via": "url", "host": parsed.netloc.lower() if parsed else ""},34    }35    if not url:36        return record37    try:38        payload = http_get(url, accept="text/html, application/xhtml+xml;q=0.9")39        parser = MetadataHTMLParser()40        parser.feed(payload.decode("utf-8", errors="ignore"))41        canonical = parser.canonical_url() or url

5960def http_get(url: str, *, accept: str = "application/json, text/plain;q=0.9, text/html;q=0.8") -> bytes:61    request = urllib.request.Request(62        url,63        headers={64            "User-Agent": USER_AGENT,65            "Accept": accept,66        },67    )68    with urllib.request.urlopen(request, timeout=REQUEST_TIMEOUT_SECONDS) as response:69        return response.read()70

6364def extract_urls(text: str) -> list[str]:65    found: list[str] = []66    for match in URL_RE.finditer(str(text or "")):67        url = match.group(0).rstrip(".,);]")68        if url not in found:69            found.append(url)70    return found71

34    }35    if not url:36        return record37    try:38        payload = http_get(url, accept="text/html, application/xhtml+xml;q=0.9")39        parser = MetadataHTMLParser()40        parser.feed(payload.decode("utf-8", errors="ignore"))41        canonical = parser.canonical_url() or url

692693def metric_payload_for_policy(item: Dict[str, Any], primary_metric: Optional[str]) -> Tuple[Optional[float], Optional[str], bool]:694    observed_metrics = item.get("observed_metrics", {})695    if primary_metric and isinstance(observed_metrics, dict) and primary_metric in observed_metrics:696        return safe_float(observed_metrics[primary_metric]), primary_metric, True697698    best_metric = item.get("best_metric")699    if primary_metric and isinstance(best_metric, dict) and best_metric.get("name") == primary_metric:700        return safe_float(best_metric.get("value")), primary_metric, True701702    fallback_value, fallback_name = default_metric_payload(item)703    return fallback_value, fallback_name, False704

735736    def sort_key(item: Dict[str, Any]) -> Tuple[int, int, float, float]:737        ranking_metric = item.get("ranking_metric")738        ranking_value = ranking_metric.get("value") if isinstance(ranking_metric, dict) else None739        fallback_value, _fallback_name = default_metric_payload(item)740        return (741            status_rank.get(item.get("status", "not_run"), 0),742            1 if item.get("matched_primary_metric") else 0,743            adjust_for_goal(ranking_value),744            adjust_for_goal(fallback_value),745        )746747    return sorted(decorated, key=sort_key, reverse=True)748

149150## Notes151152- Keep `current_research` durable and auditable.153- In campaign mode, pair `variant_spec` with a frozen task family, dataset, evaluation source, and provided SOTA table.154- Keep exploratory output candidate-only.155- Do not treat pre-execution ranking scores as trusted scientific conclusions.156- If `primary_metric` is omitted, downstream ranking falls back to parsed `best_metric`.157

201202def prune_variants(raw_variants: List[Dict[str, Any]], spec: Dict[str, Any]) -> List[Dict[str, Any]]:203    max_variants = int(spec.get("max_variants") or 0)204    max_short_cycle_runs = int(spec.get("max_short_cycle_runs") or 0)205206    ordered = sorted(207        raw_variants,208        key=lambda item: (209            -item.get("total_score", 0.0),210            -item.get("predicted_gain_score", 0.0),211            -item.get("predicted_success_score", 0.0),212            -item.get("cost_efficiency_score", 0.0),213            item.get("cost_score", 0.0),214            item.get("id", ""),215        ),216    )

8990Interpretation:9192- `cost`93  Lower runtime and smaller subsets are cheaper.94- `success_rate`95  Lighter, less aggressive candidates are more likely to run cleanly.96- `expected_gain`97  Candidates that move farther from the current setting are treated as having higher upside.9899The weights are normalized before scoring. This stage is heuristic and should be treated as exploratory prioritization, not scientific proof.100

205206    ordered = sorted(207        raw_variants,208        key=lambda item: (209            -item.get("total_score", 0.0),210            -item.get("predicted_gain_score", 0.0),211            -item.get("predicted_success_score", 0.0),212            -item.get("cost_efficiency_score", 0.0),213            item.get("cost_score", 0.0),214            item.get("id", ""),215        ),216    )217

250        },251        "selection_policy": {252            "factors": ["cost", "success_rate", "expected_gain"],253            "weights": normalize_weights(spec),254            "scores": {255                "cost_score": "Lower is cheaper; derived from steps, subset size, and axis aggressiveness.",256                "cost_efficiency_score": "Higher is cheaper after inverting cost_score.",257                "predicted_success_score": "Higher means the candidate is more likely to run cleanly.",258                "predicted_gain_score": "Higher means the candidate is more likely to produce a measurable improvement.",259                "total_score": "Weighted composite used for pre-execution candidate ranking.",260            },261        },

9899The weights are normalized before scoring. This stage is heuristic and should be treated as exploratory prioritization, not scientific proof.100101### Post-execution result ranking102103After candidates actually run, downstream ranking should use real execution evidence:104105- `status` first106- then `primary_metric`107- then `metric_goal`108