refactor: rename teacher/student to optimizer/target, remove best skills, fix slow update

- Rename teacher -> optimizer, student -> target across all code, configs, docs, prompts
- CLI: --teacher_model -> --optimizer_model, --student_model -> --target_model
- Remove best_skill files, keep only initial skills
- Fix slow update gate (force write into skill)
- Fix SLOW_UPDATE marker stripping
- Remove deep_reflect and meta_reflect mechanisms
- Update .env.example with export prefix and azure_cli docs
- Add endpoint empty validation in azure_openai.py

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

skillopt/envs/livemathematicianbench/adapter.py

@@ -4,13 +4,12 @@ from __future__ import annotations
 import json
 import os
 
-from skillopt.gradient.deep_probe import generate_deep_probe_instruction
 from skillopt.datasets.base import BatchSpec
 from skillopt.gradient.reflect import run_minibatch_reflect
 from skillopt.envs.base import EnvAdapter
 from skillopt.envs.livemathematicianbench.dataloader import LiveMathematicianBenchDataLoader
 from skillopt.envs.livemathematicianbench.rollout import run_batch
-from skillopt.model import get_student_backend
+from skillopt.model import get_target_backend
 
 
 class LiveMathematicianBenchAdapter(EnvAdapter):
@@ -61,11 +60,7 @@ class LiveMathematicianBenchAdapter(EnvAdapter):
         limit: int = 0,
         shuffle_choices: bool = True,
         use_theorem: bool = False,
-        use_sketch: bool = False,
-        use_deep_reflect: bool = False,
-        deep_reflect_failures: int = 4,
-        deep_reflect_successes: int = 2,
-    ) -> None:
+        use_sketch: bool = False,    ) -> None:
         self.max_turns = max_turns
         self.exec_timeout = exec_timeout
         self.workers = workers
@@ -75,9 +70,6 @@ class LiveMathematicianBenchAdapter(EnvAdapter):
         self.edit_budget = edit_budget
         self.use_theorem = use_theorem
         self.use_sketch = use_sketch
-        self.use_deep_reflect = use_deep_reflect
-        self.deep_reflect_failures = deep_reflect_failures
-        self.deep_reflect_successes = deep_reflect_successes
         self.dataloader = LiveMathematicianBenchDataLoader(
             split_dir=split_dir,
             data_path=data_path,
@@ -161,122 +153,6 @@ class LiveMathematicianBenchAdapter(EnvAdapter):
             update_mode=getattr(self, "_cfg", {}).get("skill_update_mode", "patch"),
         )
 
-    def deep_reflect(
-        self,
-        results: list[dict],
-        skill_content: str,
-        out_dir: str,
-        **kwargs,
-    ) -> list[dict | None]:
-        if not self.use_deep_reflect:
-            return []
-
-        env_manager = kwargs.get("env_manager")
-        prediction_dir = kwargs.get("prediction_dir", os.path.join(out_dir, "predictions"))
-        random_seed = kwargs.get("random_seed")
-        step_buffer_context = kwargs.get("step_buffer_context", "")
-        meta_skill_context = kwargs.get("meta_skill_context", "")
-        codex_backend = get_student_backend() == "codex_exec"
-        selected_items = self.select_representative_items(
-            results,
-            env_manager if isinstance(env_manager, list) else None,
-            n_failures=self.deep_reflect_failures,
-            n_successes=self.deep_reflect_successes,
-            seed=random_seed,
-        )
-        if not selected_items:
-            return []
-        selected_ids = {str(item["id"]) for item in selected_items}
-        selected_results = [row for row in results if str(row.get("id")) in selected_ids]
-        selected_examples = self.attach_reference_context(selected_results, selected_items)
-        if codex_backend:
-            selected_examples = self.attach_codex_probe_context(selected_examples, prediction_dir)
-        selected_metadata = []
-        theorem_count = 0
-        sketch_count = 0
-        for item in selected_items:
-            meta = self.get_reference_metadata(item)
-            if "theorem" in meta["fields"]:
-                theorem_count += 1
-            if "sketch" in meta["fields"]:
-                sketch_count += 1
-            selected_metadata.append({
-                "id": str(item["id"]),
-                "task_type": str(item.get("theorem_type", ["math_mcq"])[0] if item.get("theorem_type") else "math_mcq"),
-                "reference_fields": meta["fields"],
-                "reference_preview": meta["preview"],
-            })
-
-        deep_dir = os.path.join(out_dir, "deep_reflect")
-        rollout_dir = os.path.join(deep_dir, "rollout")
-        patches_dir = os.path.join(deep_dir, "patches")
-        os.makedirs(deep_dir, exist_ok=True)
-        print(
-            f"    [2b/6 DEEP REFLECT setup] selected={len(selected_items)} "
-            f"reference_fields=theorem({theorem_count}/{len(selected_items)}),"
-            f"sketch({sketch_count}/{len(selected_items)})"
-        )
-        probe = generate_deep_probe_instruction(
-            skill_content=skill_content,
-            items=selected_examples,
-            prediction_dir=prediction_dir,
-            system_prompt=self.get_codex_deep_probe_prompt() if codex_backend else self.get_deep_probe_prompt(),
-            step_buffer_context=step_buffer_context,
-            meta_skill_context=meta_skill_context,
-        )
-        if not probe:
-            return []
-        diagnostic_trace_context_by_id = None
-        if codex_backend:
-            selected_items, diagnostic_trace_context_by_id, probe = self.resolve_codex_probe_target(
-                selected_items=selected_items,
-                selected_examples=selected_examples,
-                prediction_dir=prediction_dir,
-                probe=probe,
-            )
-        probe_record = {
-            **probe,
-            "reference_summary": {
-                "selected_count": len(selected_items),
-                "field_counts": {
-                    "theorem": theorem_count,
-                    "sketch": sketch_count,
-                },
-            },
-            "selected_examples": selected_metadata,
-        }
-        with open(os.path.join(deep_dir, "probe.json"), "w", encoding="utf-8") as f:
-            json.dump(probe_record, f, ensure_ascii=False, indent=2)
-        deep_results = run_batch(
-            items=selected_items,
-            out_root=rollout_dir,
-            skill_content=skill_content,
-            max_turns=self.max_turns,
-            workers=min(self.workers, max(len(selected_items), 1)),
-            use_theorem=self.use_theorem,
-            use_sketch=self.use_sketch,
-            diagnostic_mode=True,
-            diagnostic_instruction=probe["probe_instruction"],
-            diagnostic_trace_context_by_id=diagnostic_trace_context_by_id,
-            task_timeout=self.exec_timeout,
-        )
-        deep_results = self.attach_reference_context(deep_results, selected_items)
-        return run_minibatch_reflect(
-            results=deep_results,
-            skill_content=skill_content,
-            prediction_dir=os.path.join(rollout_dir, "predictions"),
-            patches_dir=patches_dir,
-            workers=self.analyst_workers,
-            failure_only=self.failure_only,
-            minibatch_size=self.minibatch_size,
-            edit_budget=self.edit_budget,
-            random_seed=random_seed,
-            error_system=self.get_error_minibatch_prompt(),
-            success_system=self.get_success_minibatch_prompt(),
-            step_buffer_context=step_buffer_context,
-            meta_skill_context=meta_skill_context,
-            update_mode=getattr(self, "_cfg", {}).get("skill_update_mode", "patch"),
-        )
 
     def get_task_types(self) -> list[str]:
         return self.dataloader.get_task_types()

skillopt/envs/livemathematicianbench/prompts/analyst_error.md

@@ -1,7 +1,7 @@
 You are an expert failure-analysis agent for theorem-grounded mathematical multiple-choice questions.
 
 You will be given MULTIPLE failed trajectories from a single minibatch and the current skill document.
-Each trajectory includes the student's response and an evaluation result showing the predicted option
+Each trajectory includes the target's response and an evaluation result showing the predicted option
 versus the correct option.
 
 Your job is to identify COMMON reasoning failures across the batch and propose concise skill edits.

skillopt/envs/livemathematicianbench/rollout.py

@@ -7,8 +7,8 @@ import time
 from concurrent.futures import FIRST_COMPLETED, ThreadPoolExecutor, wait
 
 from skillopt.envs.livemathematicianbench.evaluator import evaluate
-from skillopt.model import chat_student, get_student_backend, is_student_exec_backend
-from skillopt.model.codex_harness import prepare_workspace, render_skill_md, run_student_exec
+from skillopt.model import chat_target, get_target_backend, is_target_exec_backend
+from skillopt.model.codex_harness import prepare_workspace, render_skill_md, run_target_exec
 from skillopt.prompts import load_prompt
 
 def _build_system(skill_content: str) -> str:
@@ -95,11 +95,11 @@ def _run_codex_once(
     work_dir = os.path.join(pred_dir, "codex_exec")
     prepare_workspace(work_dir=work_dir, skill_md=skill_md, task_text=task_text)
     prompt = (
-        "Use the `skillopt-student` skill available in this workspace.\n"
+        "Use the `skillopt-target` skill available in this workspace.\n"
         "Read `task.md` and solve the multiple-choice problem.\n"
         "Output only the final choice label inside <answer>...</answer>."
     )
-    final_message, raw = run_student_exec(
+    final_message, raw = run_target_exec(
         work_dir=work_dir,
         prompt=prompt,
         model=model,
@@ -143,7 +143,7 @@ def process_one(
         pred_dir = os.path.join(out_root, "predictions", item_id)
         os.makedirs(pred_dir, exist_ok=True)
 
-        if is_student_exec_backend():
+        if is_target_exec_backend():
             from skillopt.model import azure_openai as _llm
 
             conversation: list[dict] = []
@@ -155,7 +155,7 @@ def process_one(
                     pred_dir=pred_dir,
                     skill_content=skill_content,
                     item=item,
-                    model=_llm.STUDENT_DEPLOYMENT,
+                    model=_llm.TARGET_DEPLOYMENT,
                     timeout=exec_timeout,
                     use_theorem=use_theorem,
                     use_sketch=use_sketch,
@@ -172,9 +172,9 @@ def process_one(
             result["agent_ok"] = True
             result["n_turns"] = len(conversation)
 
-            with open(os.path.join(pred_dir, "student_system_prompt.txt"), "w", encoding="utf-8") as f:
+            with open(os.path.join(pred_dir, "target_system_prompt.txt"), "w", encoding="utf-8") as f:
                 f.write(system)
-            with open(os.path.join(pred_dir, "student_user_prompt.txt"), "w", encoding="utf-8") as f:
+            with open(os.path.join(pred_dir, "target_user_prompt.txt"), "w", encoding="utf-8") as f:
                 f.write(user)
 
             eval_result = evaluate(response, item["correct_choice"], item["choices"])
@@ -216,7 +216,7 @@ def process_one(
 
         for turn in range(max_turns):
             if turn == 0:
-                resp_text, _ = chat_student(
+                resp_text, _ = chat_target(
                     system=system,
                     user=user,
                     max_completion_tokens=16384,
@@ -230,7 +230,7 @@ def process_one(
                     "Re-evaluate the exact option wording. If needed, correct it. "
                     "Output only the final choice label inside <answer>...</answer>."
                 )
-                resp_text, _ = chat_student(
+                resp_text, _ = chat_target(
                     system=system,
                     user=refinement,
                     max_completion_tokens=16384,
@@ -247,9 +247,9 @@ def process_one(
         result["agent_ok"] = True
         result["n_turns"] = len(conversation)
 
-        with open(os.path.join(pred_dir, "student_system_prompt.txt"), "w", encoding="utf-8") as f:
+        with open(os.path.join(pred_dir, "target_system_prompt.txt"), "w", encoding="utf-8") as f:
             f.write(system)
-        with open(os.path.join(pred_dir, "student_user_prompt.txt"), "w", encoding="utf-8") as f:
+        with open(os.path.join(pred_dir, "target_user_prompt.txt"), "w", encoding="utf-8") as f:
             f.write(user)
 
         eval_result = evaluate(response, item["correct_choice"], item["choices"])