Minimal Run And Audit Skill Security Audit

12361237    chosen = choose_goal(command_data.get("commands", []), repo_path)1238    dataset_hint = derive_dataset_hint(asset_data)1239    checkpoint_hint = derive_checkpoint_hint(asset_data)1240    run_data: Dict[str, Any] = {

1291            )1292        else:1293            run_data = maybe_run_command(1294                repo_path,1295                chosen["documented_command"],1296                args.timeout,1297                args.user_language,1298                args.shell_mode,1299                runtime_root,1300                model_adapter,1301                args.monitor_gpu,1302            )1303

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:

1271        )1272    elif args.run_selected:1273        if chosen["selected_goal"] == "training":1274            run_data = maybe_run_training(1275                repo_path=repo_path,1276                command=chosen["documented_command"],1277                train_script=train_execute_script,1278                lane=args.lane,1279                user_language=args.user_language,1280                full_training_authorized=args.full_training_authorized,1281                train_timeout=args.train_timeout,1282                dataset_hint=dataset_hint,1283                checkpoint_hint=checkpoint_hint,1284                resume_from=args.resume_from,1285                max_train_steps=args.max_train_steps,1286                shell_mode=args.shell_mode,1287                runtime_root=runtime_root,1288                model_profile_json=args.model_profile_json,1289                required_model_capabilities=args.require_model_capability,1290                gpu_monitor_enabled=not args.no_gpu_monitor,1291            )1292        else:1293            run_data = maybe_run_command(1294                repo_path,1295                chosen["documented_command"],1296                args.timeout,1297                args.user_language,1298                args.shell_mode,1299                runtime_root,1300                model_adapter,1301                args.monitor_gpu,1302            )1303

494                        value = {"error": str(exc)}495                    event("tool_result", tool=name, result=value)496                    state["tool_results"].append({"type": "tool_result", "tool_use_id": call["id"],497                        "content": json.dumps(value, ensure_ascii=False), "is_error": "error" in value})498                    state["pending"].pop(0)499                    tools_this_turn += 1500                    save()501                    if pause_after_tools and tools_this_turn >= pause_after_tools and state["status"] == "running":502                        state["status"] = "paused"503                        event("paused", reason="Explicit test/session checkpoint")504                    continue505                if state["tool_results"]:506                    state["messages"].append({"role": "user", "content": state.pop("tool_results")})507                    state["tool_results"] = []

513                    break514                state["model_calls"] += 1515                state["model_pending"] = True516                state["usage_complete"] = False517                save()518                event("model_request", call=state["model_calls"], reserved_tokens=reserve)519                response = provider.complete(state["messages"], SYSTEM, TOOLS, budget["max_output_tokens"], min(60, remaining))520                if not isinstance(response, dict):

517                save()518                event("model_request", call=state["model_calls"], reserved_tokens=reserve)519                response = provider.complete(state["messages"], SYSTEM, TOOLS, budget["max_output_tokens"], min(60, remaining))520                if not isinstance(response, dict):

193    selected_runtime_root = (runtime_root or (repo / "repro_outputs" / "_runtime")).resolve()194    execution = run_persistent_command(195        repo=repo,196        command=command,197        timeout=timeout,198        runtime_root=selected_runtime_root,199        shell_mode=shell_mode,200        model_adapter=model_adapter,201        monitor_gpu=monitor_gpu,202    )203    after_status, after_capture = git_status_snapshot(repo)

1516This is local execution with credential environment filtering, not an OS sandbox.17Approved programs can access the host and network; use only trusted repositories18until an isolated executor is configured. Commands that change scientific19conditions must be explicitly reviewed. P1 targets small evaluations, not full

255    total_chars = 0256    with log_path.open("w", encoding="utf-8", newline="") as log:257        while True:258            chunk = stream.read(4096)259            if not chunk:260                break261            log.write(chunk)262            log.flush()263            capture.append(chunk)264            total_chars += len(chunk)

512513    selected_runtime_root = (runtime_root or (repo_path / "repro_outputs" / "_runtime")).resolve()514    result = run_persistent_command(515        repo=repo_path,516        command=command,517        timeout=timeout,518        runtime_root=selected_runtime_root,519        shell_mode=shell_mode,520        model_adapter=model_adapter,521        monitor_gpu=monitor_gpu,522    )523    if result.get("launch_error"):

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"48

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

20VALID_KINDS = {"failure-fix", "user-correction", "preference", "generalization"}21# Best-effort blocklist: keyword shapes plus common bare-credential formats.22# This is a guardrail, not a guarantee — callers still must not pass secrets.23SECRET_RE = re.compile(24    r"(api[_-]?key|secret|token|password|passwd|authorization|bearer\s+\S|-----BEGIN"25    r"|AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{20,}|gho_[A-Za-z0-9]{20,}|sk-[A-Za-z0-9_-]{16,}"26    r"|xox[a-z]-[A-Za-z0-9-]{10,}|AIza[0-9A-Za-z_-]{30,})",27    re.IGNORECASE,28)29MAX_FIELD_CHARS = 300

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":

6667def sanitize(text: str) -> Optional[str]:68    cleaned = " ".join(str(text or "").split())[:MAX_FIELD_CHARS]69    if not cleaned:70        return None71    if SECRET_RE.search(cleaned):72        return None73    return cleaned74

13901391    context["lesson_recorded"] = maybe_record_lesson(repo_path, context) if args.run_selected else None1392

236237def verify_task(repo: Path, output: Path, task: dict, state: dict, files: dict) -> dict:238    details = {key: command_checks(repo, task["commands"][key], state["results"].get(key, {})) for key in task["required_commands"]}239    for key, detail in details.items():240        if key in state["results"]:241            state["results"][key].update(checks=detail, verified=detail["passed"])242    current_files = inventory(repo, output)243    # Command IDs are user-defined; keep them out of the controller namespace.244    return {"commands": {key: value["passed"] for key, value in details.items()},245            "source_unchanged": all(current_files.get(name) == digest for name, digest in files.items()),246            "details": details}247