Skip to content
skillsafebeta
← Report library
Purpose / Data analysis

Ai Research Explore Skill Security Audit

What the author says it does (original text)

Rigor Explore compatible skill slug for meaningful and potentially novel deep learning research candidates. Use when the researcher has chosen the task family, dataset, benchmark, evaluation method, provided SOTA references, and wants candidate-only exploration on top of `current_research` with auditable repo understanding, idea gating, fair comparison, and governed experiments written to `explore

Independent security check

Do not install or run it yet

This check is incomplete. Only available results are shown below.

Files checked
79
Risks found
14
Could it run dangerous commands?Looks for programs run straight after downloading, remote control of your computer, and hidden commands.Risks found: 5
High risk

Campaign mode automatically executes the configured evaluation command

Source references: 7
What we found

`evaluation_source.command` is bound as a command, and every non-compatibility campaign invokes baseline evaluation independently of `--run-selected-variants`. The execution helper receives and runs that string in the target repository.

Why this matters

If the campaign file is untrusted or the user expected planning only, the command can read or modify files available to the account, start network processes, or consume CPU/GPU resources.

When a campaign file selects non-compatibility mode, the orchestrator calls baseline evaluation regardless of `--run-selected-variants`. The evaluation string is then passed as `--command` to a helper that runs it in the target worktree. A malicious, stale, or destructive `evaluation_source.command` could therefore modify files, consume compute, or access credentials available to the process. Users can ask for a separate opt-in for baseline execution and restrict commands, environment variables, network access, and writable paths.

scripts/orchestrate_explore.py:341In the codeOpen original file
def bind_evaluation_command_to_variant_spec(    variant_spec: Dict[str, Any],    evaluation_source: Dict[str, Any],) -> Dict[str, Any]:    if variant_spec.get("base_command") or not evaluation_source.get("command"):        return variant_spec    normalized = dict(variant_spec)    normalized["base_command"] = str(evaluation_source["command"]).strip()    normalized["base_command_source"] = "evaluation_source"    if evaluation_source.get("primary_metric") and not normalized.get("primary_metric"):
Show 6 other places
scripts/orchestrate_explore.py:2063In the codeOpen original file
    eval_contract = eval_contract_payload(analysis_data, campaign, metric_policy)    baseline_gate: Dict[str, Any] = {"decision": "not-applicable", "reason": "Baseline gate was not evaluated."}    baseline_payload: Dict[str, Any] = {}    if not compatibility_mode:        baseline_gate, baseline_payload, _baseline_runtime = run_baseline_evaluation(            train_execute_script=train_execute_script,            run_execute_script=run_execute_script,            repo_path=workspace_repo_path,            current_research=current_research,            evaluation_source=campaign["evaluation_source"],            baseline_gate_cfg=campaign["baseline_gate"],            runtime_root=runtime_root,            model_profile_json=args.model_profile_json,            required_model_capabilities=args.require_model_capability,            gpu_monitor_enabled=not args.no_gpu_monitor,        )        baseline_gate = compare_baseline_to_sota(
scripts/orchestrate_explore.py:1067In the codeOpen original file
    else:        run_args = [                "--repo",                str(repo_path),                "--command",                command,                "--timeout",                str(int(baseline_gate_cfg.get("timeout") or 60)),                "--runtime-root",                str(runtime_root),            ]        payload = run_json(run_execute_script, add_model_profile_args(run_args, model_profile_json, required_model_capabilities))        payload.setdefault("stop_reason", "command_completed" if payload.get("status") == "success" else "command_checked")    runtime_seconds = round(time.perf_counter() - start, 3)
scripts/orchestrate_explore.py:1988In the codeOpen original file
    parser.add_argument("--include-setup-pass", action="store_true", help="Include env-and-assets-bootstrap in the planned chain.")    parser.add_argument("--run-selected-variants", action="store_true", help="Execute a small number of exploratory variants through the trusted execution helpers.")    parser.add_argument("--max-executed-variants", type=int, default=None, help="Maximum number of exploratory variants to execute when execution is enabled.")    parser.add_argument("--variant-timeout", type=int, default=None, help="Timeout in seconds for each executed exploratory variant.")    args = parser.parse_args()
scripts/orchestrate_explore.py:345In the codeOpen original file
) -> Dict[str, Any]:    if variant_spec.get("base_command") or not evaluation_source.get("command"):        return variant_spec    normalized = dict(variant_spec)    normalized["base_command"] = str(evaluation_source["command"]).strip()    normalized["base_command_source"] = "evaluation_source"    if evaluation_source.get("primary_metric") and not normalized.get("primary_metric"):
scripts/orchestrate_explore.py:2065In the codeOpen original file
    baseline_payload: Dict[str, Any] = {}    if not compatibility_mode:        baseline_gate, baseline_payload, _baseline_runtime = run_baseline_evaluation(            train_execute_script=train_execute_script,            run_execute_script=run_execute_script,            repo_path=workspace_repo_path,            current_research=current_research,            evaluation_source=campaign["evaluation_source"],            baseline_gate_cfg=campaign["baseline_gate"],            runtime_root=runtime_root,            model_profile_json=args.model_profile_json,            required_model_capabilities=args.require_model_capability,            gpu_monitor_enabled=not args.no_gpu_monitor,        )        baseline_gate = compare_baseline_to_sota(
minimal-run-and-audit/scripts/run_command.py:306In the codeOpen original file
        parser.error(f"model profile is missing required capabilities: {', '.join(missing)}")    execution = execute_command(        repo,        args.command,        args.timeout,        args.shell_mode,        runtime_root,        model_adapter,        args.monitor_gpu,    )    metric_data = parse_metrics(combine_logs([execution.get("stdout", ""), execution.get("stderr", "")]))
High risk

The “feasibility check” imports and executes repository Python top-level code

Source references: 7
What we found

Runtime smoke checks load candidate files with `exec_module`. A Python import is not a static syntax check: top-level statements execute. The final feasibility pass invokes these probes even when no candidate variant was actually run.

Why this matters

Malicious or merely side-effectful research code can modify files, make network calls, read environment variables, or perform expensive initialization during what may appear to be analysis. Silencing output does not prevent those effects.

This is not purely static analysis: it adds the target repository to Python's search path and loads candidate files through `exec_module`, which executes module-level statements and imports. Candidates are chosen heuristically from repository filenames, and the feasibility pass invokes these probes even before candidate runs. A selected file with import-time side effects could read or write files, launch processes, or use available credentials. Users can request AST/compile-only checks or require import probes to run in an isolated process with no network, minimal environment variables, and a read-only repository.

scripts/passes/execution_feasibility.py:247In the codeOpen original file
def import_probe_check(repo_path: Path, target_location_map: Sequence[Dict[str, Any]]) -> Dict[str, Any]:    targets = safe_runtime_targets(target_location_map)    if not targets:        return {            "name": "import-probe",            "status": "passed",            "passed": [],            "blockers": [],            "notes": ["no-safe-import-targets"],        }    passed: List[str] = []    blockers: List[str] = []    sys_path_added = False    repo_root = str(repo_path)    if repo_root not in sys.path:        sys.path.insert(0, repo_root)        sys_path_added = True    try:        for item in targets:            rel = str(item.get("file") or "")            module_path = repo_path / rel            if not module_path.exists():                blockers.append(f"missing:{rel}")                continue            module_name = f"_research_explore_smoke_{hashlib.sha1(rel.encode('utf-8')).hexdigest()[:12]}"            try:                spec = importlib.util.spec_from_file_location(module_name, module_path)                if spec is None or spec.loader is None:                    blockers.append(f"import-spec:{rel}")                    continue                module = importlib.util.module_from_spec(spec)                exec_module_silenced(spec, module)                passed.append(rel)            except ModuleNotFoundError as exc:                blockers.append(f"missing-dependency:{rel}:{exc.name or 'unknown'}")            except Exception as exc:  # pragma: no cover - defensive, exercised via repo fixtures                blockers.append(f"import-error:{rel}:{exc.__class__.__name__}")            finally:
Show 6 other places
scripts/passes/execution_feasibility.py:303In the codeOpen original file
def constructor_probe_check(repo_path: Path, target_location_map: Sequence[Dict[str, Any]]) -> Dict[str, Any]:    targets = safe_runtime_targets(target_location_map)    if not targets:        return {            "name": "constructor-probe",            "status": "passed",            "passed": [],            "blockers": [],            "notes": ["constructor-probe-not-applicable"],        }    passed: List[str] = []    blockers: List[str] = []    soft_notes: List[str] = []    sys_path_added = False    repo_root = str(repo_path)    if repo_root not in sys.path:        sys.path.insert(0, repo_root)        sys_path_added = True    try:        for item in targets:            rel = str(item.get("file") or "")            target_symbol = str(item.get("target_symbol") or "")            symbol_root = target_symbol            if ":" in symbol_root:                symbol_root = symbol_root.split(":", 1)[1]            symbol_root = symbol_root.split(".", 1)[0].strip()            if not symbol_root or symbol_root == "unspecified-symbol":                soft_notes.append(f"unresolved-target-symbol:{rel}")                continue            module_path = repo_path / rel            module_name = f"_research_explore_ctor_{hashlib.sha1(rel.encode('utf-8')).hexdigest()[:12]}"            try:                spec = importlib.util.spec_from_file_location(module_name, module_path)                if spec is None or spec.loader is None:                    blockers.append(f"constructor-spec:{rel}")                    continue                module = importlib.util.module_from_spec(spec)                exec_module_silenced(spec, module)                if hasattr(module, symbol_root):
scripts/orchestrate_explore.py:2337In the codeOpen original file
    feasibility_bundle = run_execution_feasibility_pass(        analysis_output_dir=analysis_output_dir,        repo_path=workspace_repo_path,        campaign=campaign,        analysis_data=analysis_data,        variant_matrix=variant_matrix,        source_mapping=source_mapping,        executed_runs=executed_runs,    )    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')}`."))
scripts/passes/execution_feasibility.py:515In the codeOpen original file
    ]    runtime_checks = [        import_probe_check(repo_path, source_mapping.get("target_location_map", [])),        constructor_probe_check(repo_path, source_mapping.get("target_location_map", [])),        short_run_check(executed_runs, variant_matrix),    ]    static_smoke = summarize_smoke(
explore-code/scripts/plan_code_changes.py:95In the codeOpen original file
def collect_candidate_edit_targets(repo: Path, current_research: str, task_family: str) -> List[str]:    tokens = focus_tokens(current_research, task_family)    scored: List[tuple[int, str]] = []    for path in repo.rglob("*"):        if path.is_dir():            continue        if any(part in SKIP_PARTS for part in path.relative_to(repo).parts):            continue        if path.suffix.lower() not in CODE_SUFFIXES:            continue        rel = path.relative_to(repo).as_posix()        score = score_path(rel, task_family, tokens)        if score:            scored.append((score, rel))    scored.sort(key=lambda item: (-item[0], item[1]))    return [rel for _, rel in scored[:8]]
scripts/passes/execution_feasibility.py:259In the codeOpen original file
    blockers: List[str] = []    sys_path_added = False    repo_root = str(repo_path)    if repo_root not in sys.path:        sys.path.insert(0, repo_root)        sys_path_added = True    try:        for item in targets:            rel = str(item.get("file") or "")            module_path = repo_path / rel            if not module_path.exists():                blockers.append(f"missing:{rel}")                continue            module_name = f"_research_explore_smoke_{hashlib.sha1(rel.encode('utf-8')).hexdigest()[:12]}"            try:                spec = importlib.util.spec_from_file_location(module_name, module_path)                if spec is None or spec.loader is None:                    blockers.append(f"import-spec:{rel}")                    continue                module = importlib.util.module_from_spec(spec)                exec_module_silenced(spec, module)                passed.append(rel)            except ModuleNotFoundError as exc:
scripts/orchestrate_explore.py:2161In the codeOpen original file
    code_plan = initial_code_plan    feasibility_bundle = run_execution_feasibility_pass(        analysis_output_dir=analysis_output_dir,        repo_path=workspace_repo_path,        campaign=campaign,        analysis_data=analysis_data,        variant_matrix=variant_matrix,        source_mapping=source_mapping,        executed_runs=[],    )    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')}`."))
High risk

The optional model runner executes commands locally without an OS sandbox

Source references: 2
What we found

The documentation says the model reads the README, selects steps, and observes execution, while expressly stating that execution is local and not a system sandbox. Although a task file pre-limits commands, approved commands still inherit the launcher process's local privileges.

Why this matters

If an approved command, dependency, or repository script is untrusted, it could read or alter files available to the account, use credentials present in the environment, or start network and child processes. A recorded command allowlist is not operating-system isolation.

This is an optional model-driven runner, but its active commands execute locally and the documentation explicitly says it is not a system sandbox. Although a pre-reviewed task file limits commands and acceptance criteria, allowed commands may still access files or consume resources with the launching process's permissions. Users can ask for the exact command allowlist and run it under a low-privilege account, container, or isolated workspace.

ai-research-reproduction/references/agent-runner.md:167In the instructionsOpen original file
这是可选的模型执行入口。任务文件预先限定可运行命令及验收条件；模型读取原始README、选择步骤、观察执行结果，最终由独立验证器决定是否成功。原有确定性入口继续可用。恢复时使用相同参数并增加 `--resume`，状态和预算跨会话累计。这是本机执行，不是系统沙箱；P1 不支持自主修改科研代码，也不证明论文指标复现。正常暂停会保留已执行命令和证据，不再显示为“被阻塞”，也不声称整体验收完成。`agent.controller_status` 表示控制状态，`agent.task_outcome` 表示任务结果。命令可增加上述 `verification` 验收产物与 JSON 数值指标；退出码为 0 但产物缺失、指标超出容差，仍不能通过最终验收。验收条件由任务文件预先审核，模型不能修改。这些检查不单独保证产物新鲜度或科研可比性；需要时使用全新目标工作目录。
Show 1 other places
ai-research-reproduction/references/agent-runner.md:173In the instructionsOpen original file
`agent.controller_status` 表示控制状态，`agent.task_outcome` 表示任务结果。命令可增加上述 `verification` 验收产物与 JSON 数值指标；退出码为 0 但产物缺失、指标超出容差，仍不能通过最终验收。验收条件由任务文件预先审核，模型不能修改。这些检查不单独保证产物新鲜度或科研可比性；需要时使用全新目标工作目录。
Medium risk

The environment bootstrap executes repository-controlled dependency and build instructions

Source references: 4
What we found

The bootstrap selects an installation flow from a top-level `environment.yml`, `requirements.txt`, `pyproject.toml`, or `setup.py`. It runs Conda environment creation, pip requirements installation, or `pip install -e .`; these operations can execute repository build backends or downloaded package code.

Why this matters

A malicious repository or poisoned dependency can execute during installation, alter the new environment or user caches, access the network, and read files or credentials visible to the bootstrap process. A virtual environment isolates packages but is not a security sandbox.

This is supported, but only when the user actually runs the bootstrapper without `--dry-run`. It executes conda/mamba creation and pip installation based on files in the target repository; for `pyproject.toml` or `setup.py`, editable installation may invoke the repository's build backend. An untrusted repository could therefore execute code during installation or introduce malicious dependencies. Users can require pre-install confirmation, pinned dependencies, and an isolated executor.

env-and-assets-bootstrap/SKILL.md:51In the instructionsOpen original file
## NotesUse `references/env-policy.md`, `references/assets-policy.md`, `scripts/bootstrap_env.py`, `scripts/plan_setup.py`, and `scripts/prepare_assets.py`.Use `scripts/bootstrap_env.sh` only as a POSIX wrapper around the Python bootstrapper when a shell entrypoint is more convenient.
Show 3 other places
env-and-assets-bootstrap/scripts/bootstrap_env.py:23In the codeOpen original file
def run_command(command: List[str], *, cwd: Path, dry_run: bool) -> None:    print(f"+ {format_command(command)}")    if dry_run:        return    subprocess.run(command, cwd=cwd, check=True)
env-and-assets-bootstrap/scripts/bootstrap_env.py:60In the codeOpen original file
def install_with_manager(manager: str, env_name: str, repo_path: Path, rel_env_file: Optional[str], *, dry_run: bool) -> None:    if rel_env_file == "requirements.txt":        run_command(            [manager, "run", "-n", env_name, "python", "-m", "pip", "install", "-r", rel_env_file],            cwd=repo_path,            dry_run=dry_run,        )    elif rel_env_file in {"pyproject.toml", "setup.py"}:        run_command(            [manager, "run", "-n", env_name, "python", "-m", "pip", "install", "-e", "."],            cwd=repo_path,            dry_run=dry_run,        )
env-and-assets-bootstrap/scripts/bootstrap_env.py:114In the codeOpen original file
    if env_file and env_file.name in CONDA_ENV_FILES:        if manager is None:            raise SystemExit("A conda-compatible manager is required for environment.yml-based setup. Install conda or mamba first.")        create_command = [manager, "env", "create", "-f", rel_env_file]        if not declared_env_name:            create_command.extend(["-n", resolved_env_name])        run_command(create_command, cwd=repo_path, dry_run=args.dry_run)        print_activation_instructions(declared_env_name or resolved_env_name, using_conda=True)
Medium risk

Queue CPU, GPU, and memory budgets are admission declarations, not enforced process limits

Source references: 7
What we found

The queue decides whether to launch a job from its declared `resource_request`, but explicitly records the semantics as `request-based-admission-not-os-enforcement`. Jobs are then submitted as ordinary host subprocesses, with no shown cgroup, container, job-object, or GPU-quota enforcement.

Why this matters

A job that understates its needs or spikes in usage can exhaust host memory, monopolize a GPU, or disrupt other workloads; concurrent jobs amplify the effect. A timeout limits duration but cannot prevent rapid resource exhaustion.

This is supported. The queue only compares each job's declared resource request with scheduler budgets, and explicitly labels the policy as request-based admission rather than OS enforcement. Once admitted, the command is launched as a normal host subprocess. A job that understates its needs or grows during execution can therefore exhaust CPU, memory, or GPU resources and disrupt other user processes. Users can restrict concurrency and timeouts and require containers, cgroups, Windows Job Objects, or equivalent hard limits.

ai-research-reproduction/_bundled/shared/scripts/task_queue.py:193In the codeOpen original file
def _normalize_resources(value: Any) -> Dict[str, int]:    resources = value if isinstance(value, dict) else {}    result = {        "cpu_slots": int(resources.get("cpu_slots", 1)),        "gpu_slots": int(resources.get("gpu_slots", 0)),        "memory_mib": int(resources.get("memory_mib", 0)),    }    if result["cpu_slots"] < 1 or result["gpu_slots"] < 0 or result["memory_mib"] < 0:        raise ValueError("resource_request requires cpu_slots >= 1 and non-negative gpu_slots/memory_mib")    return result
Show 6 other places
ai-research-reproduction/_bundled/shared/scripts/task_queue.py:416In the codeOpen original file
def _fits(request: Dict[str, int], available: Dict[str, int]) -> bool:    return all(request[key] <= available[key] for key in ("cpu_slots", "gpu_slots", "memory_mib"))
ai-research-reproduction/_bundled/shared/scripts/task_queue.py:517In the codeOpen original file
        scheduler_id = lease.lease_id        store.state["scheduler"] = {            "status": "running",            "scheduler_id": scheduler_id,            "pid": os.getpid(),            "started_at": utc_now(),            "heartbeat_at": utc_now(),            "max_workers": max_workers,            "resource_budget": totals,            "resource_semantics": "request-based-admission-not-os-enforcement",            "fail_fast": fail_fast,        }
ai-research-reproduction/_bundled/shared/scripts/task_queue.py:619In the codeOpen original file
                            continue                        for key in available:                            available[key] -= request[key]                        job["runtime_run_id"] = new_run_id()                        store.transition(job, "running", started_at=utc_now())                        futures[executor.submit(_execute_job, dict(job))] = job                        peak_running_jobs = max(peak_running_jobs, len(futures))                        launched = True
ai-research-reproduction/_bundled/shared/scripts/task_queue.py:508In the codeOpen original file
        for job in store.jobs():            if job["status"] == "queued" and not _fits(job["resource_request"], totals):                store.transition(                    job,                    "blocked",                    "resource-request-exceeds-budget",                    finished_at=utc_now(),                    scheduler_budget=totals,                )
ai-research-reproduction/_bundled/shared/scripts/task_queue.py:518In the codeOpen original file
        scheduler_id = lease.lease_id        store.state["scheduler"] = {            "status": "running",            "scheduler_id": scheduler_id,            "pid": os.getpid(),            "started_at": utc_now(),            "heartbeat_at": utc_now(),            "max_workers": max_workers,            "resource_budget": totals,            "resource_semantics": "request-based-admission-not-os-enforcement",            "fail_fast": fail_fast,        }
ai-research-reproduction/_bundled/shared/scripts/runtime_runner.py:497In the codeOpen original file
        creationflags = subprocess.CREATE_NEW_PROCESS_GROUP if os.name == "nt" else 0        process = subprocess.Popen(            argv,            env=environment,            cwd=repo,            stdout=subprocess.PIPE,            stderr=subprocess.PIPE,            text=True,            encoding="utf-8",            errors="replace",            bufsize=1,            creationflags=creationflags,            start_new_session=os.name != "nt",        )    except (FileNotFoundError, ShellSyntaxRequired, OSError, ValueError) as exc:
Could it expose your files or keys?Looks for uploads of files containing passwords or keys, and keys written directly in the code.Risks found: 3
Medium risk

Run information is persisted in the user profile by default and can influence later projects

Source references: 6
What we found

Lesson recording is enabled by default. On partial or blocked reproduction runs, the orchestrator appends the blocker summary, documented command, and repository fingerprint to `~/.rigorpilot/lessons.jsonl`; the exploration Skill is then instructed to consult the generated `PERSONAL_RIGOR.md`. A credential-pattern filter exists, but its own comment says it is not a guarantee.

Why this matters

Research project names, path fragments, failure details, and command arguments can remain outside the expected output directory, appear in shared-account backups, and influence decisions for unrelated future projects. Secret formats not recognized by the regular expression may also be stored.

This is supported, with limited scope: recording occurs only when execution was requested and the result is partial/blocked, or when a prior failure is later resolved. Recording is enabled by default and appends a blocker summary, command detail, and repository fingerprint under the user's home directory. The exploration skill is told to consult the overlay later, so prior records may influence advice for other projects. Secret filtering is explicitly best-effort. Users can set `RIGORPILOT_LESSONS=0` and require preview or consent before persistence.

ai-research-reproduction/_bundled/shared/scripts/lessons_store.py:21In the codeOpen original file
VALID_KINDS = {"failure-fix", "user-correction", "preference", "generalization"}# Best-effort blocklist: keyword shapes plus common bare-credential formats.# This is a guardrail, not a guarantee — callers still must not pass secrets.SECRET_RE = re.compile(    r"(api[_-]?key|secret|token|password|passwd|authorization|bearer\s+\S|-----BEGIN"    r"|AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{20,}|gho_[A-Za-z0-9]{20,}|sk-[A-Za-z0-9_-]{16,}"    r"|xox[a-z]-[A-Za-z0-9-]{10,}|AIza[0-9A-Za-z_-]{30,})",    re.IGNORECASE,)MAX_FIELD_CHARS = 300
Show 5 other places
ai-research-reproduction/_bundled/shared/scripts/lessons_store.py:41In the codeOpen original file
def lessons_home() -> Path:    root = os.environ.get("RIGORPILOT_HOME")    return Path(root).expanduser() if root else Path.home() / ".rigorpilot"def lessons_enabled() -> bool:    return os.environ.get("RIGORPILOT_LESSONS", "1") != "0"def lessons_path() -> Path:    return lessons_home() / "lessons.jsonl"def overlay_path() -> Path:    return lessons_home() / "PERSONAL_RIGOR.md"
ai-research-reproduction/scripts/orchestrate_repro.py:62In the codeOpen original file
    try:        if status in {"partial", "blocked"}:            path = store.record_lesson(                kind="failure-fix",                skill="ai-research-reproduction",                summary=f"[{status}] {context.get('main_blocker', 'unrecorded blocker')}",                detail=str(context.get("documented_command") or ""),                fingerprint=fingerprint,            )            return str(path) if path else None
ai-research-reproduction/_bundled/shared/scripts/lessons_store.py:125In the codeOpen original file
    }    path = lessons_path()    path.parent.mkdir(parents=True, exist_ok=True)    with path.open("a", encoding="utf-8") as handle:        handle.write(json.dumps(entry, ensure_ascii=False) + "\n")    return path
ai-research-reproduction/scripts/orchestrate_repro.py:54In the codeOpen original file
def maybe_record_lesson(repo_path: Path, context: Dict[str, Any]) -> Optional[str]:    """Record failure blockers and later resolutions per the continuous-learning policy."""    store = load_lessons_store()    if store is None or not store.lessons_enabled():        return None    fingerprint = store.repo_fingerprint(repo_path)    status = context.get("status")    try:        if status in {"partial", "blocked"}:            path = store.record_lesson(                kind="failure-fix",                skill="ai-research-reproduction",                summary=f"[{status}] {context.get('main_blocker', 'unrecorded blocker')}",                detail=str(context.get("documented_command") or ""),                fingerprint=fingerprint,            )            return str(path) if path else None        if status == "success":
SKILL.md:118In the instructionsOpen original file
  details.- 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.- Load `../ai-research-reproduction/references/research-rigor-principles.md` before making novelty, contribution, SOTA, or comparability statements.- Consult `~/.rigorpilot/PERSONAL_RIGOR.md` if present, under `../ai-research-reproduction/references/continuous-learning-policy.md` (advisory only; core wins).- Load `../ai-research-reproduction/references/deep-learning-experiment-principles.md` when training,
Medium risk

Repository-discovered URLs are resolved and may be contacted by default

Source references: 6
What we found

Repository locator extraction defaults to enabled, and every extracted record is passed to GitHub, arXiv, DOI, or generic-URL providers. Provider results are explicitly marked `network-fetched`.

Why this matters

Opening an untrusted repository can make the machine contact author-supplied external or internal addresses, exposing request timing, source IP, and the requested URL, and potentially reaching services visible only from the user's network. The shown evidence does not establish that credentials are sent.

Repository-local locator extraction is enabled by default, and extracted values are resolved alongside other seeds. Recognized GitHub, arXiv, DOI, and generic URLs are dispatched to provider resolvers; successful provider results are explicitly marked `network-fetched`. Thus, recognizable URLs in repository text may cause requests that reveal timing and source IP, and could target internal URLs. Users can disable `enable_repo_local_extraction`, deny network access, or require an allowlist plus private-network address blocking.

scripts/passes/lookup_sources.py:324In the codeOpen original file
) -> Dict[str, Any]:    sources_dir.mkdir(parents=True, exist_ok=True)    output_dir = analysis_output_dir or (sources_dir.parent / "analysis_outputs")    output_dir.mkdir(parents=True, exist_ok=True)    lookup_config = campaign.get("research_lookup", {}) if isinstance(campaign.get("research_lookup"), dict) else {}    seed_records = collect_seed_records(campaign, analysis_data, code_plan)    repo_local_seeds = extract_repo_local_seeds(repo_path) if lookup_config.get("enable_repo_local_extraction", True) else []    raw_records = dedupe_preserving_order([*seed_records, *repo_local_seeds])    resolved_records = [resolve_provider_record(raw, lookup_config) for raw in raw_records]    stored_bundle = store_records(sources_dir, resolved_records)    records = stored_bundle["records"]
Show 5 other places
scripts/passes/lookup_sources.py:235In the codeOpen original file
            break    if locator_info:        optional_record = resolve_optional_record(locator_info, lookup_config)        resolved = optional_record or {}        if not resolved:            provider_type = locator_info.get("provider_type")            if provider_type == "github":                resolved = resolve_github_record(locator_info)            elif provider_type == "arxiv":                resolved = resolve_arxiv_record(locator_info)            elif provider_type == "doi":                resolved = resolve_doi_record(locator_info)            elif provider_type == "url":                resolved = resolve_url_record(locator_info)            else:
scripts/lookup/normalizers.py:139In the codeOpen original file
def parse_generic_url(locator: str) -> Optional[Dict[str, Any]]:    text = canonicalize_url(locator)    if not HTTP_URL_RE.match(text):        return None    parsed = urllib.parse.urlsplit(text)    return {        "provider_type": "url",        "source_type": "web",        "locator_type": "url",        "raw_locator": str(locator or "").strip(),        "normalized_id": f"url:{text}",        "identifier": text,        "host": parsed.netloc.lower(),        "url": text,    }
scripts/lookup/providers/github_provider.py:69In the codeOpen original file
        readme_meta = _fetch_readme(owner, repo)        return {            **record,            "title": str(payload.get("full_name") or record["title"]),            "summary": str(payload.get("description") or ""),            "url": str(payload.get("html_url") or record["url"]),            "repo_full_name": str(payload.get("full_name") or repo_full_name),            "parse_status": "resolved",            "fetch_status": "network-fetched",            "evidence_class": "external_provider",            "provider_metadata": {
scripts/lookup/repo_extractors.py:84In the codeOpen original file
        locators = _extract_locators(text)        relative_path = path.relative_to(repo_root).as_posix()        for locator in locators:            if locator in seen_locators:                continue            seen_locators.add(locator)            seeds.append(                {                    "kind": _classify_kind(locator),                    "title": locator,                    "summary": f"Repo-local extracted source from `{relative_path}`.",                    "query": locator,                    "source_url": locator if locator.lower().startswith("http") else "",                    "source_repo": "",                    "source_file": "",                    "source_symbol": "",                    "origin": "repo_local_extracted",                    "raw_locator": locator,                    "extracted_from_repo_paths": [relative_path],                }
scripts/lookup/providers/github_provider.py:73In the codeOpen original file
            "summary": str(payload.get("description") or ""),            "url": str(payload.get("html_url") or record["url"]),            "repo_full_name": str(payload.get("full_name") or repo_full_name),            "parse_status": "resolved",            "fetch_status": "network-fetched",            "evidence_class": "external_provider",            "provider_metadata": {
Medium risk

Model requests and persistent traces may contain private research or repository content

Source references: 3
What we found

The runner transmits requests over HTTP to the selected model service and locally stores messages, requests, responses, tool activity, and results. Its own documentation warns against publishing private-repository traces without review.

Why this matters

When a remote model is enabled, task or README material supplied to the model leaves the machine. The local trace also creates a sensitive copy of research context and actions; sharing the output directory or publishing traces can disclose it further.

The documentation supports both model HTTP requests and detailed local persistence: state stores messages and results, while traces store requests, responses, and tool activity. It explicitly warns that private-repository traces must be reviewed before publication. Thus, private code or research data present in prompts, tool output, or responses may enter model requests or local traces. Users should confirm the model provider, retention policy, and trace location, and restrict sensitive context and trace publication.

ai-research-reproduction/references/agent-runner.md:115In the instructionsOpen original file
Optional `parameters` are transmitted, not just recorded: the current transportsupports `temperature` or `top_p` (not both), and `stop_sequences`. Unsupportedfields are rejected before HTTP; `max_tokens` remains controlled by the taskbudget. Leave sampling settings absent unless the selected model supports them:the [Messages API](https://platform.claude.com/docs/en/api/messages/create)deprecates these controls for newer models. A local protocol test is not acompatibility claim for every model or gateway.
Show 2 other places
ai-research-reproduction/references/agent-runner.md:125In the instructionsOpen original file
The standard README bundle is accompanied by `agent_state.json` (task/modelidentity, messages, plan, pending calls, results), `trajectory.jsonl` (requests,responses, public reasons, tools and usage), and `_runtime/` process evidence.The verifier requires all `required_commands` to pass their exit/stdout and any
ai-research-reproduction/references/agent-runner.md:161In the instructionsOpen original file
gateway token accounting may differ. Output size is checked between actions,not an OS disk quota. `CANCEL` is checked between actions; use the runtime CANCELfile to stop an active process. Credentials are not included in provider errors.Do not publish traces from private repositories without reviewing their contents.
Could it delete files or keep running?Looks for broad file deletion, disk overwrites, and programs set to start automatically.Risks found: 3
Low risk

Initialization creates a hidden sibling worktree and a new Git branch

Source references: 3
What we found

The worktree location is placed under the Git root's parent directory. If the branch does not exist, the orchestrator uses `git worktree add -b` to create both the branch and full worktree before the main scan and planning stages.

Why this matters

A new branch, worktree, and hidden directory remain on disk. Large repositories may consume significant space and the added worktree can affect later branch management or cleanup.

The orchestrator places its worktree in a hidden directory beside the Git root. If the experiment branch does not exist, it runs `git worktree add -b`, creating both a branch and a full worktree from the current HEAD. This is an intended isolation mechanism, but it still creates persistent files and Git references outside the requested output directory and may consume substantial disk space. Users can confirm the location and cleanup policy first or require use of an explicitly supplied existing isolated branch.

scripts/orchestrate_explore.py:127In the codeOpen original file
def experiment_worktree_root(git_root: Path, experiment_branch: str) -> Path:    base_dir = git_root.parent / f".{git_root.name}-explore-worktrees" / slugify(experiment_branch)    return base_dir / git_root.name
Show 2 other places
scripts/orchestrate_explore.py:222In the codeOpen original file
    worktree_root = experiment_worktree_root(git_root, experiment_branch)    if worktree_root.exists():        worktree_info = validate_existing_worktree(worktree_root, experiment_branch)    else:        worktree_root.parent.mkdir(parents=True, exist_ok=True)        if branch_exists:            run_text(["git", "worktree", "add", str(worktree_root), experiment_branch], cwd=git_root)        else:            run_text(["git", "worktree", "add", "-b", experiment_branch, str(worktree_root), head_sha], cwd=git_root)            created_branch = True        branch_sha = run_text(["git", "rev-parse", "--verify", branch_ref], cwd=git_root)        worktree_info = validate_existing_worktree(worktree_root, experiment_branch)
scripts/orchestrate_explore.py:2019In the codeOpen original file
    durable_current_research = validate_current_research(repo_path, current_research)    experiment_branch = choose_experiment_branch(current_research, args.experiment_branch)    workspace_info = ensure_experiment_workspace(repo_path, experiment_branch)    context_id = build_context_id(current_research, experiment_branch)    workspace_repo_path = Path(workspace_info["workspace_root"]).resolve()    helper_stage_trace = [        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']}`."),        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']}`."),    ]    scan_data = run_json(scan_script, ["--repo", str(workspace_repo_path), "--json"])    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}`."))
Low risk

An optional flag writes a persistent file beside the source README

Source references: 2
What we found

With source-adjacent-readme enabled, the tool creates RIGORPILOT_README.md in the original README directory instead of keeping all material in the dedicated output directory. The documentation says conflicting files are not overwritten.

Why this matters

The source repository gains a file that Git may detect, a user may accidentally commit, or another tool may consume. A repeat run may refresh an unchanged tool-owned copy.

Legitimate use of this code

Writing beside the source README is an explicitly optional feature that occurs only when `--source-adjacent-readme` is supplied. The file is an annotated copy preserving the original content; ordinary evidence remains in the output directory, conflicting or unrelated files are not overwritten, and the original README stays intact. Users who do not want an extra source-directory file can omit the flag and ask to confirm the reported destination.

This assessment concerns the code and conditions shown, not proof that harm has occurred.
ai-research-reproduction/references/output-spec.md:176In the instructionsOpen original file
## Optional source-adjacent READMEAdd `--source-adjacent-readme` to `orchestrate_repro.py` or `run_agent.py` toalso create `RIGORPILOT_README.md` in the original README's directory. Keepthe standard `repro_outputs/ANNOTATED_README.md` and its evidence files.
Show 1 other places
ai-research-reproduction/references/output-spec.md:189In the instructionsOpen original file
The bundle retains `readme_delivery.json` to identify its generated copy.Repeating with the same source and output may refresh an unchanged owned copy.An unrelated or edited file, symlink, hard link, or conflicting receipt is notoverwritten. Keep the receipt with the evidence; do not use it to claim thatsource code or external media were verified. The original README remains intact.
Low risk

Failed and later-resolved runs are recorded as durable lessons by default

Source references: 1
What we found

The skill states that failed and subsequently resolved runs are automatically recorded through lessons_store.py unless RIGORPILOT_LESSONS=0 is set.

Why this matters

This creates an additional persistent record outside the immediate campaign artifacts. It may contain project failure or research-process information and may influence later runs that consume those lessons. The supplied lines do not show its stored fields or retention period.

What this evidence establishes

The entrypoint does say failed and later-resolved runs are recorded as lessons by default and provides an opt-out variable. However, the supplied source does not show the recorded fields, storage location, retention period, or any external transmission, so the concrete privacy or account impact of “long-term experience” cannot be established. Users can set `RIGORPILOT_LESSONS=0` before running and ask the author what is stored, where, and how it is removed.

This assessment concerns the code and conditions shown, not proof that harm has occurred.
ai-research-reproduction/SKILL.md:123In the instructionsOpen original file
- Load `references/deep-learning-experiment-principles.md` when dataset, split, metric, checkpoint, training, or evaluation details matter.- Consult `~/.rigorpilot/PERSONAL_RIGOR.md` if present, under `references/continuous-learning-policy.md` (advisory only; core wins).- Failed and later-resolved runs are auto-recorded as lessons via `shared/scripts/lessons_store.py` (`RIGORPILOT_LESSONS=0` disables).- Load `references/research-safety-principles.md` before protocol-sensitive
Could it bypass safety checks?Looks for skipped website security checks, excessive file access, or actions that skip your approval.Risks found: 1
Medium risk

Generic source resolution can request arbitrary HTTP(S) locations without shown private-network or response-size controls

Source references: 5
What we found

Source extraction collects URLs from repository text, and the generic URL provider passes a normalized address directly to `urlopen`. The shown code has no host allowlist and no rejection of loopback, link-local, or private networks; `response.read()` also has no byte limit.

Why this matters

A URL planted in a repository or campaign can make the host contact an internal administration endpoint, cloud metadata service, or local service, creating an SSRF path. A large response can also pressure memory. The supplied lines do not establish external exfiltration, but internal responses enter the local research-record processing chain.

This is supported when source lookup resolves URLs extracted from repository files. The extractor accepts arbitrary HTTP(S) URLs, and the generic provider fetches the resulting URL directly. The visible transport code has no host/IP-range validation and calls `response.read()` without a byte limit. A malicious repository could induce requests to localhost, private networks, or cloud metadata services, or return a large response that consumes memory. Users can require an allowlist, private/loopback/link-local blocking, and a response-size cap.

scripts/lookup/repo_extractors.py:51In the codeOpen original file
def _extract_locators(text: str) -> List[str]:    found: List[str] = []    for url in extract_urls(text):        if url not in found:            found.append(url)    for pattern in (ARXIV_ID_RE, DOI_RE):        for match in pattern.finditer(text):            raw = match.group(0).strip()            if raw and raw not in found:                found.append(raw)    return found
Show 4 other places
scripts/lookup/providers/url_provider.py:13In the codeOpen original file
def resolve_url_record(locator_info: Dict[str, Any]) -> Dict[str, Any]:    url = canonicalize_url(locator_info.get("url") or locator_info.get("raw_locator") or "")    parsed = urllib.parse.urlsplit(url) if url else None    record = {        "provider_type": "url",        "source_type": "web",        "locator_type": locator_info.get("locator_type", "url"),        "raw_locator": locator_info.get("raw_locator", ""),        "normalized_id": locator_info.get("normalized_id", f"url:{url}" if url else ""),        "title": url,        "url": url,        "authors": [],        "year": None,        "venue": parsed.netloc if parsed else "",        "repo_full_name": "",        "doi": "",        "arxiv_id": "",        "parse_status": "parsed-only",        "fetch_status": "parsed-only",        "evidence_class": "parsed_locator",        "provider_metadata": {"resolved_via": "url", "host": parsed.netloc.lower() if parsed else ""},    }    if not url:        return record    try:        payload = http_get(url, accept="text/html, application/xhtml+xml;q=0.9")        parser = MetadataHTMLParser()        parser.feed(payload.decode("utf-8", errors="ignore"))        canonical = parser.canonical_url() or url
scripts/lookup/providers/base.py:60In the codeOpen original file
def http_get(url: str, *, accept: str = "application/json, text/plain;q=0.9, text/html;q=0.8") -> bytes:    request = urllib.request.Request(        url,        headers={            "User-Agent": USER_AGENT,            "Accept": accept,        },    )    with urllib.request.urlopen(request, timeout=REQUEST_TIMEOUT_SECONDS) as response:        return response.read()
scripts/lookup/normalizers.py:64In the codeOpen original file
def extract_urls(text: str) -> list[str]:    found: list[str] = []    for match in URL_RE.finditer(str(text or "")):        url = match.group(0).rstrip(".,);]")        if url not in found:            found.append(url)    return found
scripts/lookup/providers/url_provider.py:35In the codeOpen original file
    }    if not url:        return record    try:        payload = http_get(url, accept="text/html, application/xhtml+xml;q=0.9")        parser = MetadataHTMLParser()        parser.feed(payload.decode("utf-8", errors="ignore"))        canonical = parser.canonical_url() or url
Could it mislead the AI or hide text?Checks the skill instructions for requests to ignore you, influence the report, or hide text in invisible characters.No risks found
Could it change links or payment recipients without asking?Looks for forced referral or payment changes combined with instructions to hide the change.Risks found: 2
Medium risk

Run ranking can use the last arbitrary non-loss metric when the primary metric is missing

Source references: 4
What we found

The training log parser designates the last non-loss/error metric as `best_metric` without comparing which value is actually best. If the primary metric is absent, ranking explicitly falls back to that value.

Why this matters

Logs containing several metrics, or merely changing metric order, can cause the wrong measurement to select the “best” candidate and misdirect compute spending, research direction, or SOTA comparisons.

Training-log parsing does not calculate the true best value across steps. It excludes names containing terms such as loss/error and then selects the last inserted non-loss metric; if only loss-like metrics exist, it selects the last metric or validation loss. When the configured primary metric is unavailable, ranking falls back to this `best_metric`. An unrelated log metric could therefore affect candidate ordering and subsequent trial recommendations. Users can require an exact primary-metric match, make unmatched runs unrankable, and specify metric direction and aggregation.

run-train/scripts/run_training.py:97In the codeOpen original file
    priority_names = [        name for name in observed_metrics        if not any(token in name.lower() for token in {"loss", "error", "rmse", "mae", "wer", "cer"})    ]    if priority_names:        chosen = priority_names[-1]        best_metric = {"name": chosen, "value": observed_metrics[chosen]}    elif observed_metrics:        validation_losses = [name for name in observed_metrics if name.lower() in {"val_loss", "validation_loss", "valid_loss"}]        chosen = validation_losses[-1] if validation_losses else list(observed_metrics)[-1]        best_metric = {"name": chosen, "value": observed_metrics[chosen]}
Show 3 other places
scripts/orchestrate_explore.py:693In the codeOpen original file
def metric_payload_for_policy(item: Dict[str, Any], primary_metric: Optional[str]) -> Tuple[Optional[float], Optional[str], bool]:    observed_metrics = item.get("observed_metrics", {})    if primary_metric and isinstance(observed_metrics, dict) and primary_metric in observed_metrics:        return safe_float(observed_metrics[primary_metric]), primary_metric, True    best_metric = item.get("best_metric")    if primary_metric and isinstance(best_metric, dict) and best_metric.get("name") == primary_metric:        return safe_float(best_metric.get("value")), primary_metric, True    fallback_value, fallback_name = default_metric_payload(item)    return fallback_value, fallback_name, False
scripts/orchestrate_explore.py:736In the codeOpen original file
    def sort_key(item: Dict[str, Any]) -> Tuple[int, int, float, float]:        ranking_metric = item.get("ranking_metric")        ranking_value = ranking_metric.get("value") if isinstance(ranking_metric, dict) else None        fallback_value, _fallback_name = default_metric_payload(item)        return (            status_rank.get(item.get("status", "not_run"), 0),            1 if item.get("matched_primary_metric") else 0,            adjust_for_goal(ranking_value),            adjust_for_goal(fallback_value),        )    return sorted(decorated, key=sort_key, reverse=True)
ai-research-reproduction/references/explore-variant-spec.md:150In the instructionsOpen original file
## Notes- Keep `current_research` durable and auditable.- In campaign mode, pair `variant_spec` with a frozen task family, dataset, evaluation source, and provided SOTA table.- Keep exploratory output candidate-only.- Do not treat pre-execution ranking scores as trusted scientific conclusions.- If `primary_metric` is omitted, downstream ranking falls back to parsed `best_metric`.
Low risk

Pre-execution “predicted success/gain” scores are fixed formulas, not model or dataset evidence

Source references: 6
What we found

Success decreases with axis aggressiveness, steps, and subset size, while expected gain increases from the same factors; the resulting synthetic scores directly order candidates. The formula uses no historical run results or task-specific evidence.

Why this matters

Users may mistake fields named `predicted_success_score` and `predicted_gain_score` for validated predictions, prioritize unsuitable candidates, and waste compute.

Legitimate use of this code

The stated formulas and their use in ordering are real, but both code and documentation frame them as pre-execution heuristic prioritization—not model predictions, historical estimates, or scientific evidence. Post-execution ranking separately uses status and observed metrics. The main concern is that users could overread the `predicted_*` names; the supplied context explicitly explains the scores and their limitations, so this is not supported as concealed or falsely represented evidence. Users can still ask that the UI label them “heuristic” and review weights before allocating compute.

This assessment concerns the code and conditions shown, not proof that harm has occurred.
explore-run/scripts/plan_variants.py:129In the codeOpen original file
    for item in raw_variants:        subset_scale = normalized_lookup_score(item.get("subset_size"), subset_lookup)        step_scale = normalized_lookup_score(item.get("short_run_steps"), step_lookup)        axis_scale = axis_aggressiveness_score(item.get("axes", {}), axes)        raw_cost = 0.50 * step_scale + 0.35 * subset_scale + 0.15 * axis_scale        cost_efficiency_score = clamp_score(1.0 - raw_cost)        predicted_success_score = clamp_score(1.0 - (0.45 * axis_scale + 0.35 * step_scale + 0.20 * subset_scale))        predicted_gain_score = clamp_score(0.50 * axis_scale + 0.30 * step_scale + 0.20 * subset_scale)        total_score = (            weights["cost"] * cost_efficiency_score            + weights["success_rate"] * predicted_success_score            + weights["expected_gain"] * predicted_gain_score        )        annotated_item = dict(item)        annotated_item.update(            {                "cost_score": round(raw_cost, 4),                "cost_efficiency_score": round(cost_efficiency_score, 4),                "predicted_success_score": round(predicted_success_score, 4),                "predicted_gain_score": round(predicted_gain_score, 4),                "total_score": round(total_score, 4),                "estimated_runtime_units": round(1.0 + 3.0 * step_scale + 2.0 * subset_scale + axis_scale, 4),                "feasibility_annotations": [],
Show 5 other places
explore-run/scripts/plan_variants.py:202In the codeOpen original file
def prune_variants(raw_variants: List[Dict[str, Any]], spec: Dict[str, Any]) -> List[Dict[str, Any]]:    max_variants = int(spec.get("max_variants") or 0)    max_short_cycle_runs = int(spec.get("max_short_cycle_runs") or 0)    ordered = sorted(        raw_variants,        key=lambda item: (            -item.get("total_score", 0.0),            -item.get("predicted_gain_score", 0.0),            -item.get("predicted_success_score", 0.0),            -item.get("cost_efficiency_score", 0.0),            item.get("cost_score", 0.0),            item.get("id", ""),        ),    )
ai-research-reproduction/references/explore-variant-spec.md:90In the instructionsOpen original file
Interpretation:- `cost`  Lower runtime and smaller subsets are cheaper.- `success_rate`  Lighter, less aggressive candidates are more likely to run cleanly.- `expected_gain`  Candidates that move farther from the current setting are treated as having higher upside.The weights are normalized before scoring. This stage is heuristic and should be treated as exploratory prioritization, not scientific proof.
explore-run/scripts/plan_variants.py:206In the codeOpen original file
    ordered = sorted(        raw_variants,        key=lambda item: (            -item.get("total_score", 0.0),            -item.get("predicted_gain_score", 0.0),            -item.get("predicted_success_score", 0.0),            -item.get("cost_efficiency_score", 0.0),            item.get("cost_score", 0.0),            item.get("id", ""),        ),    )
explore-run/scripts/plan_variants.py:251In the codeOpen original file
        },        "selection_policy": {            "factors": ["cost", "success_rate", "expected_gain"],            "weights": normalize_weights(spec),            "scores": {                "cost_score": "Lower is cheaper; derived from steps, subset size, and axis aggressiveness.",                "cost_efficiency_score": "Higher is cheaper after inverting cost_score.",                "predicted_success_score": "Higher means the candidate is more likely to run cleanly.",                "predicted_gain_score": "Higher means the candidate is more likely to produce a measurable improvement.",                "total_score": "Weighted composite used for pre-execution candidate ranking.",            },        },
ai-research-reproduction/references/explore-variant-spec.md:99In the instructionsOpen original file
The weights are normalized before scoring. This stage is heuristic and should be treated as exploratory prioritization, not scientific proof.### Post-execution result rankingAfter candidates actually run, downstream ranking should use real execution evidence:- `status` first- then `primary_metric`- then `metric_goal`

Inside this skill

7 instruction sections

The Skill plans or runs candidate research only after explicit authorization and a durable `current_research` anchor; its instructions freeze the dataset, evaluation, SOTA reference, and budget and label results as exploratory evidence.

View source
SKILL.md:28In the instructionsOpen original file
Use this skill only when the request has both:- Explicit exploration authorization such as candidate-only work, isolated  branch or worktree, sweep, several variants, or exploratory ranking.- A durable `current_research` context such as a branch, commit, checkpoint,  run record, or already-trained local model state.
SKILL.md:56In the instructionsOpen original file
1. Confirm `current_research` and explicit explore-lane authorization.2. Accept either legacy `variant_spec` or higher-level `research_campaign`.3. In campaign mode, freeze the task, dataset, benchmark, evaluation source,   SOTA reference, and budget before candidate work.4. Build only the repo-understanding artifacts needed for the current campaign,
SKILL.md:73In the instructionsOpen original file
   requires real execution evidence.9. Write candidate-only outputs to `analysis_outputs/`, `sources/`, and   `explore_outputs/` as appropriate; never present exploratory gains as trusted   reproduction success. Include `SCIENTIFIC_CHANGELOG.md` and   `COMPARABILITY_REPORT.md` for candidate scientific meaning and comparison   boundaries.

The bundled runtime launches a child process in the selected repository and persists full stdout, stderr, resource samples, state, and events in a per-run directory. On timeout or cancellation, it terminates the process group.

View source
ai-research-reproduction/_bundled/shared/scripts/runtime_runner.py:480In the codeOpen original file
    stderr_capture = TailBuffer(capture_limit)    stdout_path = run_dir / "stdout.log"    stderr_path = run_dir / "stderr.log"    resources_path = run_dir / "resources.jsonl"    stdout_path.touch()    stderr_path.touch()    resources_path.touch()    try:        argv = build_command(command, shell_mode)        environment = dict(os.environ if child_env is None else child_env)        spec["requested_argv"] = list(argv)        atomic_write_json(run_dir / "spec.json", spec)        if shell_mode == "direct":            argv = resolve_direct_argv(argv, repo, environment)        spec["argv"] = list(argv)        atomic_write_json(run_dir / "spec.json", spec)        creationflags = subprocess.CREATE_NEW_PROCESS_GROUP if os.name == "nt" else 0        process = subprocess.Popen(            argv,            env=environment,            cwd=repo,            stdout=subprocess.PIPE,            stderr=subprocess.PIPE,            text=True,            encoding="utf-8",            errors="replace",            bufsize=1,            creationflags=creationflags,            start_new_session=os.name != "nt",        )    except (FileNotFoundError, ShellSyntaxRequired, OSError, ValueError) as exc:
ai-research-reproduction/_bundled/shared/scripts/runtime_runner.py:555In the codeOpen original file
            now = time.monotonic()            if cancel_path.exists():                cancelled = True                journal.event("cancel_detected", source="CANCEL")                _terminate_process_tree(process, journal)                break            if timeout >= 0 and now - started_monotonic >= timeout:                timed_out = True                journal.event("timeout_detected", timeout_seconds=timeout)                _terminate_process_tree(process, journal)                break            if now >= next_heartbeat:

Research-source resolution can contact arXiv, DOI, GitHub, and generic web pages. The shared transport has a six-second timeout, but the shown implementation places no size limit on the response body.

View source
scripts/lookup/providers/__init__.py:3In the codeOpen original file
from .arxiv_provider import resolve_arxiv_recordfrom .doi_provider import resolve_doi_recordfrom .github_provider import resolve_github_recordfrom .optional_provider import resolve_optional_recordfrom .url_provider import resolve_url_record
scripts/lookup/providers/base.py:60In the codeOpen original file
def http_get(url: str, *, accept: str = "application/json, text/plain;q=0.9, text/html;q=0.8") -> bytes:    request = urllib.request.Request(        url,        headers={            "User-Agent": USER_AGENT,            "Accept": accept,        },    )    with urllib.request.urlopen(request, timeout=REQUEST_TIMEOUT_SECONDS) as response:        return response.read()

The companion reproduction flow enables a cross-run personal lesson store by default: blocker information and command summaries can be written to `~/.rigorpilot/lessons.jsonl` and later distilled into `PERSONAL_RIGOR.md` for Skill use; an environment variable can disable it.

View source
ai-research-reproduction/_bundled/shared/scripts/lessons_store.py:41In the codeOpen original file
def lessons_home() -> Path:    root = os.environ.get("RIGORPILOT_HOME")    return Path(root).expanduser() if root else Path.home() / ".rigorpilot"def lessons_enabled() -> bool:    return os.environ.get("RIGORPILOT_LESSONS", "1") != "0"def lessons_path() -> Path:    return lessons_home() / "lessons.jsonl"def overlay_path() -> Path:    return lessons_home() / "PERSONAL_RIGOR.md"
ai-research-reproduction/scripts/orchestrate_repro.py:62In the codeOpen original file
    try:        if status in {"partial", "blocked"}:            path = store.record_lesson(                kind="failure-fix",                skill="ai-research-reproduction",                summary=f"[{status}] {context.get('main_blocker', 'unrecorded blocker')}",                detail=str(context.get("documented_command") or ""),                fingerprint=fingerprint,            )            return str(path) if path else None
SKILL.md:120In the instructionsOpen original file
- Load `../ai-research-reproduction/references/research-rigor-principles.md` before making novelty, contribution, SOTA, or comparability statements.- Consult `~/.rigorpilot/PERSONAL_RIGOR.md` if present, under `../ai-research-reproduction/references/continuous-learning-policy.md` (advisory only; core wins).- Load `../ai-research-reproduction/references/deep-learning-experiment-principles.md` when training,

The Skill is intended for explicitly authorized candidate exploration with a durable `current_research` baseline; its description explicitly rejects treating candidate results as verified novelty or trusted reproduction.

View source
SKILL.md:10In the instructionsOpen original file
Use this as the Rigor Explore compatible skill slug after the researcherexplicitly authorizes candidate-only work on top of a durable`current_research` anchor. The installed slug remains `ai-research-explore` forcompatibility. Rigor Explore is for meaningful and potentially novel deeplearning research candidates while preserving scientific rigor, comparability,reproducibility, and auditable collaboration. Novelty and significance remainhypotheses before literature contrast, ablation evidence, and fair comparison.The skill does not promise autonomous discovery, global benchmark completeness,novelty proof, or trusted reproduction success.
SKILL.md:28In the instructionsOpen original file
Use this skill only when the request has both:- Explicit exploration authorization such as candidate-only work, isolated  branch or worktree, sweep, several variants, or exploratory ranking.- A durable `current_research` context such as a branch, commit, checkpoint,  run record, or already-trained local model state.

The orchestrator creates or reuses an isolated Git branch/worktree and writes analysis, source-cache, and exploration artifacts into several output directories.

View source
scripts/orchestrate_explore.py:222In the codeOpen original file
    worktree_root = experiment_worktree_root(git_root, experiment_branch)    if worktree_root.exists():        worktree_info = validate_existing_worktree(worktree_root, experiment_branch)    else:        worktree_root.parent.mkdir(parents=True, exist_ok=True)        if branch_exists:            run_text(["git", "worktree", "add", str(worktree_root), experiment_branch], cwd=git_root)        else:            run_text(["git", "worktree", "add", "-b", experiment_branch, str(worktree_root), head_sha], cwd=git_root)            created_branch = True        branch_sha = run_text(["git", "rev-parse", "--verify", branch_ref], cwd=git_root)
scripts/orchestrate_explore.py:1993In the codeOpen original file
    repo_path = Path(args.repo).resolve()    output_dir = Path(args.output_dir).resolve()    runtime_root = Path(args.runtime_root).resolve() if args.runtime_root else output_dir / "_runtime"    try:        model_adapter = load_model_profile(Path(args.model_profile_json) if args.model_profile_json else None)        missing_model_capabilities = missing_capabilities(model_adapter, args.require_model_capability)    except ModelAdapterError as exc:        parser.error(str(exc))    if missing_model_capabilities:        parser.error(f"model profile is missing required capabilities: {', '.join(missing_model_capabilities)}")    analysis_output_dir = output_dir.parent / "analysis_outputs"    analysis_output_dir.mkdir(parents=True, exist_ok=True)    sources_dir = output_dir.parent / "sources"

Candidate variant execution is controlled by an execution policy and suppressed by an abandoned baseline, a human checkpoint, or a blocked manifest; baseline evaluation is nevertheless executed separately and automatically in campaign mode.

View source
scripts/orchestrate_explore.py:2307In the codeOpen original file
    short_run_runtime_seconds = 0.0    should_run_variants = bool(campaign["execution_policy"]["run_selected_variants"])    if not compatibility_mode and baseline_gate.get("decision") == "abandon":        should_run_variants = False    if not compatibility_mode and checkpoint_state != "not-required":        should_run_variants = False    if experiment_manifest.get("status") == "blocked":        should_run_variants = False    if should_run_variants:        if variant_matrix.get("base_command") and variant_matrix.get("variants"):
scripts/orchestrate_explore.py:2063In the codeOpen original file
    eval_contract = eval_contract_payload(analysis_data, campaign, metric_policy)    baseline_gate: Dict[str, Any] = {"decision": "not-applicable", "reason": "Baseline gate was not evaluated."}    baseline_payload: Dict[str, Any] = {}    if not compatibility_mode:        baseline_gate, baseline_payload, _baseline_runtime = run_baseline_evaluation(            train_execute_script=train_execute_script,            run_execute_script=run_execute_script,            repo_path=workspace_repo_path,            current_research=current_research,            evaluation_source=campaign["evaluation_source"],            baseline_gate_cfg=campaign["baseline_gate"],            runtime_root=runtime_root,            model_profile_json=args.model_profile_json,            required_model_capabilities=args.require_model_capability,            gpu_monitor_enabled=not args.no_gpu_monitor,        )        baseline_gate = compare_baseline_to_sota(

Source lookup extracts locators from repository files by default, attempts external-provider resolution, and persists resolved records under `sources/records` plus an index.

View source
scripts/passes/lookup_sources.py:324In the codeOpen original file
) -> Dict[str, Any]:    sources_dir.mkdir(parents=True, exist_ok=True)    output_dir = analysis_output_dir or (sources_dir.parent / "analysis_outputs")    output_dir.mkdir(parents=True, exist_ok=True)    lookup_config = campaign.get("research_lookup", {}) if isinstance(campaign.get("research_lookup"), dict) else {}    seed_records = collect_seed_records(campaign, analysis_data, code_plan)    repo_local_seeds = extract_repo_local_seeds(repo_path) if lookup_config.get("enable_repo_local_extraction", True) else []    raw_records = dedupe_preserving_order([*seed_records, *repo_local_seeds])    resolved_records = [resolve_provider_record(raw, lookup_config) for raw in raw_records]    stored_bundle = store_records(sources_dir, resolved_records)    records = stored_bundle["records"]
scripts/lookup/cache_store.py:153In the codeOpen original file
        record["source_id"] = source_id        slug = slugify(record.get("title") or normalized_id)        filename = stable_filename(str(record.get("source_type") or "source"), slug, digest)        artifact_path = records_dir / filename        record["artifact_path"] = f"sources/records/{filename}"        record["artifact_abspath"] = str(artifact_path)        record["digest"] = digest        artifact_path.write_text(            json.dumps({"schema_version": "2.0", **record}, indent=2, ensure_ascii=False),            encoding="utf-8",        )        stored_records.append(record)

The skill is intended to start only after the researcher explicitly authorizes candidate exploration and supplies a durable current_research baseline such as a branch, commit, checkpoint, or trained state.

View source
SKILL.md:28In the instructionsOpen original file
Use this skill only when the request has both:- Explicit exploration authorization such as candidate-only work, isolated  branch or worktree, sweep, several variants, or exploratory ranking.- A durable `current_research` context such as a branch, commit, checkpoint,  run record, or already-trained local model state.

The workflow makes or runs one bounded candidate, smoke-checks it, collects evidence, and ranks it against the current baseline; it is instructed to stop at blockers, exhausted budget, or a human checkpoint.

View source
SKILL.md:43In the instructionsOpen original file
- Outer loop: understand the repository, freeze task/dataset/evaluation/budget,  preserve user ideas, map sources, gate ideas, and decide whether the next  experiment is worth running.- Inner loop: make one bounded candidate change or run, smoke-check it, collect  evidence, rank it against the current anchor, and either stop or return to the  outer loop with the new evidence.This rhythm is a guide, not a rigid autonomous loop. Stop at explicit blockers,unclear scientific meaning, exhausted budget, missing anchor/evaluation, or ahuman checkpoint.

Campaign mode generates research maps, scores, plans, run ledgers, and status records under analysis_outputs, sources, and explore_outputs; a minimal campaign should create only artifacts justified by the active work.

View source
references/research-campaign-spec.md:287In the instructionsOpen original file
## Output ExpectationsThe following artifacts are the full advanced campaign surface. A minimalcampaign should produce only the files justified by the active work; do notinflate the run with empty artifacts just to satisfy this list.Campaign mode writes:
references/research-campaign-spec.md:295In the instructionsOpen original file
- `analysis_outputs/RESEARCH_MAP.md`- `analysis_outputs/CHANGE_MAP.md`- `analysis_outputs/EVAL_CONTRACT.md`- `analysis_outputs/SOURCE_INVENTORY.md`- `analysis_outputs/SOURCE_SUPPORT.json`- `analysis_outputs/IMPROVEMENT_BANK.md`- `analysis_outputs/IDEA_CARDS.json`- `analysis_outputs/IDEA_SEEDS.json`- `analysis_outputs/IDEA_EVALUATION.md`- `analysis_outputs/IDEA_SCORES.json`- `analysis_outputs/MODULE_CANDIDATES.md`- `analysis_outputs/INTERFACE_DIFF.md`- `analysis_outputs/ATOMIC_IDEA_MAP.md`- `analysis_outputs/ATOMIC_IDEA_MAP.json`- `analysis_outputs/IMPLEMENTATION_FIDELITY.md`- `analysis_outputs/IMPLEMENTATION_FIDELITY.json`- `analysis_outputs/RESOURCE_PLAN.md`- `analysis_outputs/status.json`- `sources/index.json`- `sources/SUMMARY.md`- `sources/records/`- `explore_outputs/CHANGESET.md`- `explore_outputs/IDEA_GATE.md`- `explore_outputs/EXPERIMENT_PLAN.md`- `explore_outputs/EXPERIMENT_MANIFEST.md`- `explore_outputs/EXPERIMENT_LEDGER.md`- `explore_outputs/TRANSPLANT_SMOKE_REPORT.md`- `explore_outputs/TOP_RUNS.md`- `explore_outputs/status.json`

The accompanying model runner retains detailed evidence including messages, requests, responses, tool activity, usage, and process logs, and explicitly warns that traces from private repositories require review before publication.

View source
ai-research-reproduction/references/agent-runner.md:125In the instructionsOpen original file
The standard README bundle is accompanied by `agent_state.json` (task/modelidentity, messages, plan, pending calls, results), `trajectory.jsonl` (requests,responses, public reasons, tools and usage), and `_runtime/` process evidence.The verifier requires all `required_commands` to pass their exit/stdout and any
ai-research-reproduction/references/agent-runner.md:161In the instructionsOpen original file
gateway token accounting may differ. Output size is checked between actions,not an OS disk quota. `CANCEL` is checked between actions; use the runtime CANCELfile to stop an active process. Credentials are not included in provider errors.Do not publish traces from private repositories without reviewing their contents.
Start here · InstructionsSKILL.md
ai-research-explore
Lines connect the instruction file to its sections, not an observed execution order. Select a section to read the source.

File reference map

References: 40
Files making referencesReferenced content
Lines show actual file references, not execution order. Select a node to highlight its connections and inspect the files and source locations. Dashed lines include files that still need locating.
Files and check records79 files

Coverage and gaps

  • Some results did not pass evidence validation or finish processing. This report does not represent a complete check.
Content covered in each file

These are the source ranges included in this check, not a guarantee that every issue has been resolved.

  • SKILL.mdFull text included
  • ai-research-reproduction/_bundled/shared/scripts/lessons_store.pyFull text included
  • ai-research-reproduction/_bundled/shared/scripts/runtime_runner.pyFull text included
  • ai-research-reproduction/_bundled/shared/scripts/task_queue.pyFull text included
  • ai-research-reproduction/scripts/orchestrate_repro.pyFull text included
  • ai-research-reproduction/scripts/run_agent.pyFull text included
  • env-and-assets-bootstrap/scripts/bootstrap_env.pyFull text included
  • env-and-assets-bootstrap/scripts/bootstrap_env.shFull text included
  • env-and-assets-bootstrap/scripts/plan_setup.pyFull text included
  • env-and-assets-bootstrap/scripts/prepare_assets.pyFull text included
  • explore-code/scripts/plan_code_changes.pyFull text included
  • explore-code/scripts/write_outputs.pyFull text included
  • explore-run/scripts/plan_variants.pyFull text included
  • explore-run/scripts/write_outputs.pyFull text included
  • minimal-run-and-audit/scripts/run_command.pyFull text included
  • minimal-run-and-audit/scripts/write_outputs.pyFull text included
  • run-train/scripts/run_training.pyFull text included
  • run-train/scripts/write_outputs.pyFull text included
  • scripts/lookup/__init__.pyFull text included
  • scripts/lookup/cache_store.pyFull text included
  • scripts/lookup/inventory_writer.pyFull text included
  • scripts/lookup/normalizers.pyFull text included
  • scripts/lookup/providers/__init__.pyFull text included
  • scripts/lookup/providers/arxiv_provider.pyFull text included
  • scripts/lookup/providers/base.pyFull text included
  • scripts/lookup/providers/doi_provider.pyFull text included
  • scripts/lookup/providers/github_provider.pyFull text included
  • scripts/lookup/providers/optional_provider.pyFull text included
  • scripts/lookup/providers/url_provider.pyFull text included
  • scripts/lookup/record_schema.pyFull text included
  • scripts/lookup/repo_extractors.pyFull text included
  • scripts/lookup/source_support.pyFull text included
  • scripts/orchestrate_explore.pyFull text included
  • scripts/passes/__init__.pyFull text included
  • scripts/passes/atomic_idea_decomposition.pyFull text included
  • scripts/passes/candidate_idea_generation.pyFull text included
  • scripts/passes/execution_feasibility.pyFull text included
  • scripts/passes/idea_cards.pyFull text included
  • scripts/passes/idea_ranking.pyFull text included
  • scripts/passes/implementation_fidelity.pyFull text included
  • scripts/passes/improvement_bank.pyFull text included
  • scripts/passes/lookup_sources.pyFull text included
  • scripts/passes/source_mapping.pyFull text included
  • scripts/write_outputs.pyFull text included
  • references/ai-research-explore-policy.mdFull text included
  • references/research-campaign-spec.mdFull text included
  • ai-research-reproduction/references/agent-operating-principles.mdFull text included
  • ai-research-reproduction/references/agent-runner.mdFull text included
  • ai-research-reproduction/references/continuous-learning-policy.mdFull text included
  • ai-research-reproduction/references/deep-learning-experiment-principles.mdFull text included
  • ai-research-reproduction/references/explore-variant-spec.mdFull text included
  • ai-research-reproduction/references/language-policy.mdFull text included
  • ai-research-reproduction/references/output-spec.mdFull text included
  • ai-research-reproduction/references/patch-policy.mdFull text included
  • ai-research-reproduction/references/research-pitfall-checklist.mdFull text included
  • ai-research-reproduction/references/research-rigor-principles.mdFull text included
  • ai-research-reproduction/references/research-safety-principles.mdFull text included
  • ai-research-reproduction/references/runtime-and-model-adapter.mdFull text included
  • analyze-project/references/analysis-policy.mdFull text included
  • env-and-assets-bootstrap/references/assets-policy.mdFull text included
  • env-and-assets-bootstrap/references/env-policy.mdFull text included
  • explore-code/references/explore-policy.mdFull text included
  • explore-run/references/execution-policy.mdFull text included
  • minimal-run-and-audit/references/reporting-policy.mdFull text included
  • repo-intake-and-plan/references/repo-scan-rules.mdFull text included
  • run-train/references/training-policy.mdFull text included
  • ai-research-reproduction/SKILL.mdFull text included
  • analyze-project/SKILL.mdFull text included
  • env-and-assets-bootstrap/SKILL.mdFull text included
  • explore-code/SKILL.mdFull text included
  • explore-run/SKILL.mdFull text included
  • minimal-run-and-audit/SKILL.mdFull text included
  • repo-intake-and-plan/SKILL.mdFull text included
  • run-train/SKILL.mdFull text included
  • agents/openai.yamlFull text included
  • references/idea-evaluation-framework.mdFull text included
  • references/smoke-validation-policy.mdFull text included
  • references/source-mapping-policy.mdFull text included
  • references/sources-naming-policy.mdFull text included

This report is for the version above. We read the available code and instructions without running the skill or checking extra packages it installs. This is not a promise of safety: a different version or setup may behave differently.

  • SKILL.mdInstructions
  • agents/openai.yamlSupporting file
  • references/ai-research-explore-policy.mdSupporting file
  • references/idea-evaluation-framework.mdSupporting file
  • references/research-campaign-spec.mdSupporting file
  • references/smoke-validation-policy.mdSupporting file
  • references/source-mapping-policy.mdSupporting file
  • references/sources-naming-policy.mdSupporting file
  • scripts/lookup/__init__.pyScript
  • scripts/lookup/cache_store.pyScript
  • scripts/lookup/inventory_writer.pyScript
  • scripts/lookup/normalizers.pyScript
  • scripts/lookup/providers/__init__.pyScript
  • scripts/lookup/providers/arxiv_provider.pyScript
  • scripts/lookup/providers/base.pyScript
  • scripts/lookup/providers/doi_provider.pyScript
  • scripts/lookup/providers/github_provider.pyScript
  • scripts/lookup/providers/optional_provider.pyScript
  • scripts/lookup/providers/url_provider.pyScript
  • scripts/lookup/record_schema.pyScript
  • scripts/lookup/repo_extractors.pyScript
  • scripts/lookup/source_support.pyScript
  • scripts/orchestrate_explore.pyScript
  • scripts/passes/__init__.pyScript
  • scripts/passes/atomic_idea_decomposition.pyScript
  • scripts/passes/candidate_idea_generation.pyScript
  • scripts/passes/execution_feasibility.pyScript
  • scripts/passes/idea_cards.pyScript
  • scripts/passes/idea_ranking.pyScript
  • scripts/passes/implementation_fidelity.pyScript
  • scripts/passes/improvement_bank.pyScript
  • scripts/passes/lookup_sources.pyScript
  • scripts/passes/source_mapping.pyScript
  • scripts/write_outputs.pyScript
  • ai-research-reproduction/SKILL.mdSupporting file
  • ai-research-reproduction/references/agent-operating-principles.mdSupporting file
  • ai-research-reproduction/references/research-rigor-principles.mdSupporting file
  • ai-research-reproduction/references/deep-learning-experiment-principles.mdSupporting file
  • ai-research-reproduction/scripts/orchestrate_repro.pyScript
  • ai-research-reproduction/references/runtime-and-model-adapter.mdSupporting file
  • ai-research-reproduction/references/agent-runner.mdSupporting file
  • ai-research-reproduction/scripts/run_agent.pyScript
  • ai-research-reproduction/references/patch-policy.mdSupporting file
  • ai-research-reproduction/references/output-spec.mdSupporting file
  • ai-research-reproduction/references/language-policy.mdSupporting file
  • ai-research-reproduction/references/continuous-learning-policy.mdSupporting file
  • ai-research-reproduction/_bundled/shared/scripts/lessons_store.pyScript
  • ai-research-reproduction/references/research-safety-principles.mdSupporting file
  • run-train/SKILL.mdSupporting file
  • minimal-run-and-audit/SKILL.mdSupporting file
  • repo-intake-and-plan/SKILL.mdSupporting file
  • env-and-assets-bootstrap/SKILL.mdSupporting file
  • analyze-project/SKILL.mdSupporting file
  • explore-code/SKILL.mdSupporting file
  • explore-run/SKILL.mdSupporting file
  • ai-research-reproduction/_bundled/shared/scripts/runtime_runner.pyScript
  • ai-research-reproduction/_bundled/shared/scripts/task_queue.pyScript
  • run-train/references/training-policy.mdSupporting file
  • run-train/scripts/run_training.pyScript
  • run-train/scripts/write_outputs.pyScript
  • minimal-run-and-audit/references/reporting-policy.mdSupporting file
  • minimal-run-and-audit/scripts/run_command.pyScript
  • minimal-run-and-audit/scripts/write_outputs.pyScript
  • repo-intake-and-plan/references/repo-scan-rules.mdSupporting file
  • env-and-assets-bootstrap/references/env-policy.mdSupporting file
  • env-and-assets-bootstrap/references/assets-policy.mdSupporting file
  • env-and-assets-bootstrap/scripts/bootstrap_env.pyScript
  • env-and-assets-bootstrap/scripts/plan_setup.pyScript
  • env-and-assets-bootstrap/scripts/prepare_assets.pyScript
  • env-and-assets-bootstrap/scripts/bootstrap_env.shScript
  • analyze-project/references/analysis-policy.mdSupporting file
  • ai-research-reproduction/references/research-pitfall-checklist.mdSupporting file
  • explore-code/references/explore-policy.mdSupporting file
  • explore-code/scripts/plan_code_changes.pyScript
  • explore-code/scripts/write_outputs.pyScript
  • explore-run/references/execution-policy.mdSupporting file
  • ai-research-reproduction/references/explore-variant-spec.mdSupporting file
  • explore-run/scripts/plan_variants.pyScript
  • explore-run/scripts/write_outputs.pyScript

Operations mentioned in code and instructions

Read files
scripts/lookup/cache_store.py:32In the codeOpen original file
        }    payload = json.loads(index_path.read_text(encoding="utf-8"))    records = payload.get("records", [])
scripts/lookup/cache_store.py:126In the codeOpen original file
            if existing_path and existing_path.exists():                existing_payload = json.loads(existing_path.read_text(encoding="utf-8"))            merged = merge_records(existing_payload, record)
scripts/lookup/providers/base.py:68In the codeOpen original file
    )    with urllib.request.urlopen(request, timeout=REQUEST_TIMEOUT_SECONDS) as response:        return response.read()
Change files
scripts/lookup/cache_store.py:159In the codeOpen original file
        record["digest"] = digest        artifact_path.write_text(            json.dumps({"schema_version": "2.0", **record}, indent=2, ensure_ascii=False),
scripts/lookup/cache_store.py:202In the codeOpen original file
    index_path = sources_dir / "index.json"    index_path.write_text(json.dumps(index_payload, indent=2, ensure_ascii=False), encoding="utf-8")    return {
scripts/lookup/inventory_writer.py:35In the codeOpen original file
    summary_path = sources_dir / "SUMMARY.md"    summary_path.write_text("\n".join(lines), encoding="utf-8")    return summary_path
Connect to websites
scripts/lookup/normalizers.py:43In the codeOpen original file
    if text.lower().startswith("doi:"):        return f"https://doi.org/{text[4:].strip()}"    return text
scripts/lookup/normalizers.py:88In the codeOpen original file
        "arxiv_id": arxiv_id,        "url": f"https://arxiv.org/abs/{arxiv_id}",    }
scripts/lookup/normalizers.py:107In the codeOpen original file
        "doi": doi,        "url": f"https://doi.org/{doi}",    }
Read keys or account settings
scripts/lookup/providers/optional_provider.py:10In the codeOpen original file
OPTIONAL_PROVIDER_ENV_VARS = {    "openrouter": "RESEARCH_LOOKUP_OPENROUTER_API_KEY",    "perplexity": "RESEARCH_LOOKUP_PERPLEXITY_API_KEY",
scripts/lookup/providers/optional_provider.py:11In the codeOpen original file
    "openrouter": "RESEARCH_LOOKUP_OPENROUTER_API_KEY",    "perplexity": "RESEARCH_LOOKUP_PERPLEXITY_API_KEY",    "parallel": "RESEARCH_LOOKUP_PARALLEL_API_KEY",
scripts/lookup/providers/optional_provider.py:12In the codeOpen original file
    "perplexity": "RESEARCH_LOOKUP_PERPLEXITY_API_KEY",    "parallel": "RESEARCH_LOOKUP_PARALLEL_API_KEY",}
Run commands
scripts/orchestrate_explore.py:10In the codeOpen original file
import reimport subprocessimport sys
scripts/orchestrate_explore.py:63In the codeOpen original file
def run_json(script: Path, args: List[str]) -> Dict[str, Any]:    result = subprocess.run([sys.executable, str(script), *args], check=True, capture_output=True, text=True)    return json.loads(result.stdout)
scripts/orchestrate_explore.py:77In the codeOpen original file
def run_text(command: List[str], cwd: Optional[Path] = None) -> str:    result = subprocess.run(command, check=True, capture_output=True, text=True, cwd=str(cwd) if cwd else None)    return result.stdout.strip()
Install extra software packages
ai-research-reproduction/scripts/orchestrate_repro.py:252In the codeOpen original file
        score -= 10    if text_value.startswith(("pip install", "conda install", "conda env create", "conda activate", "git clone", "cd ")):        score -= 12
env-and-assets-bootstrap/scripts/plan_setup.py:99In the codeOpen original file
    elif env_file.name == "requirements.txt":        append_venv_flow(setup_commands, f"python -m pip install -r {rel_env_file}")        notes.append("Fell back to a virtualenv plus requirements installation plan.")
env-and-assets-bootstrap/scripts/plan_setup.py:102In the codeOpen original file
    elif env_file.name == "pyproject.toml":        append_venv_flow(setup_commands, "python -m pip install -e .")        notes.append("Detected a pyproject-based installation flow.")
Lines read
15,367
File checksum (to compare versions)
69dd2f19f74e2c8ba9659638dbf17880cb729d5625ac8dd00476e9a675f5bd2c