self-evolve-framework 1.3.0 → 1.5.0

package/template/skills/skillopt-sleep/scripts/shell/train.py

@@ -0,0 +1,556 @@
+#!/usr/bin/env python3
+"""SkillOpt unified training entry point.
+
+Usage
+-----
+    python scripts/train.py --config configs/alfworld/default.yaml
+
+Any YAML key can be overridden from the command line::
+
+    python scripts/train.py --config configs/alfworld/default.yaml \\
+        --batch_size 40 --num_epochs 2 --seed 123
+
+Run ``python scripts/train.py --help`` for a full list of options.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime
+import os
+import sys
+
+# Ensure the project root is on sys.path so ``import skillopt`` works
+# regardless of where the script is invoked from.
+_SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+_PROJECT_ROOT = os.path.dirname(_SCRIPT_DIR)
+if _PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, _PROJECT_ROOT)
+
+from skillopt.model.common import default_model_for_backend, normalize_backend_name
+
+_OPENAI_DEFAULT_MODEL_SENTINELS = {"gpt-5.4", "gpt-5.5"}
+
+
+# ── Environment registry ────────────────────────────────────────────────────
+
+_ENV_REGISTRY: dict[str, type] = {}
+
+
+def _register_builtins() -> None:
+    """Lazy-import built-in adapters so we don't pull heavy deps at CLI parse time."""
+    try:
+        from skillopt.envs.alfworld.adapter import ALFWorldAdapter
+        _ENV_REGISTRY["alfworld"] = ALFWorldAdapter
+    except ImportError:
+        pass  # ALFWorld deps not installed — skip
+    try:
+        from skillopt.envs.searchqa.adapter import SearchQAAdapter
+        _ENV_REGISTRY["searchqa"] = SearchQAAdapter
+    except ImportError:
+        pass
+    try:
+        from skillopt.envs.livemathematicianbench.adapter import LiveMathematicianBenchAdapter
+        _ENV_REGISTRY["livemathematicianbench"] = LiveMathematicianBenchAdapter
+    except ImportError:
+        pass
+    try:
+        from skillopt.envs.babyvision.adapter import BabyVisionAdapter
+        _ENV_REGISTRY["babyvision"] = BabyVisionAdapter
+    except ImportError:
+        pass
+    try:
+        from skillopt.envs.spreadsheetbench.adapter import SpreadsheetBenchAdapter
+        _ENV_REGISTRY["spreadsheetbench"] = SpreadsheetBenchAdapter
+    except ImportError:
+        pass
+    try:
+        from skillopt.envs.mmrb.adapter import MMRBAdapter
+        _ENV_REGISTRY["mmrb"] = MMRBAdapter
+    except ImportError:
+        pass
+    try:
+        from skillopt.envs.docvqa.adapter import DocVQAAdapter
+        _ENV_REGISTRY["docvqa"] = DocVQAAdapter
+    except ImportError:
+        pass
+    try:
+        from skillopt.envs.mathverse.adapter import MathVerseAdapter
+        _ENV_REGISTRY["mathverse"] = MathVerseAdapter
+    except ImportError:
+        pass
+    try:
+        from skillopt.envs.officeqa.adapter import OfficeQAAdapter
+        _ENV_REGISTRY["officeqa"] = OfficeQAAdapter
+    except ImportError:
+        pass
+    try:
+        from skillopt.envs.sealqa.adapter import SealQAAdapter
+        _ENV_REGISTRY["sealqa"] = SealQAAdapter
+    except ImportError:
+        pass
+    try:
+        from skillopt.envs.swebench.adapter import SWEBenchAdapter
+        _ENV_REGISTRY["swebench"] = SWEBenchAdapter
+    except ImportError:
+        pass
+
+
+def get_adapter(cfg: dict):
+    """Instantiate the environment adapter specified in ``cfg["env"]``."""
+    _register_builtins()
+    env_name = cfg.get("env", "alfworld")
+    if env_name not in _ENV_REGISTRY:
+        raise ValueError(
+            f"Unknown environment '{env_name}'. "
+            f"Available: {list(_ENV_REGISTRY.keys())}"
+        )
+    adapter_cls = _ENV_REGISTRY[env_name]
+
+    # Inspect adapter __init__ signature and only pass accepted kwargs
+    import inspect
+    sig = inspect.signature(adapter_cls.__init__)
+    accepted = set(sig.parameters.keys()) - {"self"}
+    adapter_kwargs: dict = {}
+    for key in accepted:
+        if key in cfg:
+            adapter_kwargs[key] = cfg[key]
+
+    return adapter_cls(**adapter_kwargs)
+
+
+# ── CLI ──────────────────────────────────────────────────────────────────────
+
+_BOOL = lambda x: x.lower() in ("true", "1", "yes")  # noqa: E731
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="SkillOpt: Executive Strategy for Self-Evolving Agent Skills",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    p.add_argument("--config", type=str, required=True,
+                   help="Path to YAML config file")
+    p.add_argument("--cfg-options", nargs="+", default=[],
+                   help="Override config: section.key=value (e.g. train.batch_size=40)")
+
+    # Legacy flat CLI overrides (still work, prefer --cfg-options for new usage)
+    p.add_argument("--env", type=str)
+    p.add_argument("--backend", type=str,
+                   choices=["azure_openai", "codex", "codex_exec", "claude", "claude_chat", "claude_code_exec", "qwen", "qwen_chat", "minimax", "minimax_chat"])
+    p.add_argument("--optimizer_model", type=str)
+    p.add_argument("--target_model", type=str)
+    p.add_argument("--optimizer_backend", type=str)
+    p.add_argument("--target_backend", type=str)
+    p.add_argument("--reasoning_effort", type=str,
+                   choices=["", "low", "medium", "high", "xhigh", "max"])
+    p.add_argument("--rewrite_reasoning_effort", type=str)
+    p.add_argument("--rewrite_max_completion_tokens", type=int)
+    p.add_argument("--azure_endpoint", type=str)
+    p.add_argument("--azure_api_version", type=str)
+    p.add_argument("--azure_api_key", type=str)
+    p.add_argument("--azure_openai_endpoint", type=str)
+    p.add_argument("--azure_openai_api_version", type=str)
+    p.add_argument("--azure_openai_api_key", type=str)
+    p.add_argument("--azure_openai_auth_mode", type=str)
+    p.add_argument("--azure_openai_ad_scope", type=str)
+    p.add_argument("--azure_openai_managed_identity_client_id", type=str)
+    p.add_argument("--optimizer_azure_openai_endpoint", type=str)
+    p.add_argument("--optimizer_azure_openai_api_version", type=str)
+    p.add_argument("--optimizer_azure_openai_api_key", type=str)
+    p.add_argument("--optimizer_azure_openai_auth_mode", type=str)
+    p.add_argument("--optimizer_azure_openai_ad_scope", type=str)
+    p.add_argument("--optimizer_azure_openai_managed_identity_client_id", type=str)
+    p.add_argument("--target_azure_openai_endpoint", type=str)
+    p.add_argument("--target_azure_openai_api_version", type=str)
+    p.add_argument("--target_azure_openai_api_key", type=str)
+    p.add_argument("--target_azure_openai_auth_mode", type=str)
+    p.add_argument("--target_azure_openai_ad_scope", type=str)
+    p.add_argument("--target_azure_openai_managed_identity_client_id", type=str)
+    p.add_argument("--qwen_chat_base_url", type=str)
+    p.add_argument("--qwen_chat_api_key", type=str)
+    p.add_argument("--qwen_chat_temperature", type=float)
+    p.add_argument("--qwen_chat_timeout_seconds", type=float)
+    p.add_argument("--qwen_chat_max_tokens", type=int)
+    p.add_argument("--qwen_chat_enable_thinking", type=_BOOL)
+    p.add_argument("--optimizer_qwen_chat_base_url", type=str)
+    p.add_argument("--optimizer_qwen_chat_api_key", type=str)
+    p.add_argument("--optimizer_qwen_chat_temperature", type=float)
+    p.add_argument("--optimizer_qwen_chat_timeout_seconds", type=float)
+    p.add_argument("--optimizer_qwen_chat_max_tokens", type=int)
+    p.add_argument("--optimizer_qwen_chat_enable_thinking", type=_BOOL)
+    p.add_argument("--target_qwen_chat_base_url", type=str)
+    p.add_argument("--target_qwen_chat_api_key", type=str)
+    p.add_argument("--target_qwen_chat_temperature", type=float)
+    p.add_argument("--target_qwen_chat_timeout_seconds", type=float)
+    p.add_argument("--target_qwen_chat_max_tokens", type=int)
+    p.add_argument("--target_qwen_chat_enable_thinking", type=_BOOL)
+    p.add_argument("--minimax_base_url", type=str)
+    p.add_argument("--minimax_api_key", type=str)
+    p.add_argument("--minimax_model", type=str)
+    p.add_argument("--minimax_temperature", type=float)
+    p.add_argument("--minimax_max_tokens", type=int)
+    p.add_argument("--minimax_enable_thinking", type=_BOOL)
+    p.add_argument("--codex_exec_path", type=str)
+    p.add_argument("--codex_exec_sandbox", type=str)
+    p.add_argument("--codex_exec_profile", type=str)
+    p.add_argument("--codex_exec_full_auto", type=_BOOL)
+    p.add_argument("--codex_exec_reasoning_effort", type=str)
+    p.add_argument("--codex_exec_use_sdk", type=str)
+    p.add_argument("--codex_exec_network_access", type=_BOOL)
+    p.add_argument("--codex_exec_web_search", type=_BOOL)
+    p.add_argument("--codex_exec_approval_policy", type=str)
+    p.add_argument("--claude_code_exec_path", type=str)
+    p.add_argument("--claude_code_exec_profile", type=str)
+    p.add_argument("--claude_code_exec_use_sdk", type=str)
+    p.add_argument("--claude_code_exec_effort", type=str)
+    p.add_argument("--claude_code_exec_max_thinking_tokens", type=int)
+    p.add_argument("--codex_trace_to_optimizer", type=_BOOL)
+    p.add_argument("--skill_init", type=str)
+    p.add_argument("--num_epochs", type=int)
+    p.add_argument("--train_size", type=int)
+    p.add_argument("--steps_per_epoch", type=int)
+    p.add_argument("--batch_size", type=int)
+    p.add_argument("--accumulation", type=int)
+    p.add_argument("--seed", type=int)
+    p.add_argument("--edit_budget", type=int)
+    p.add_argument("--min_edit_budget", type=int)
+    p.add_argument("--lr_scheduler", type=str,
+                   choices=["constant", "linear", "cosine", "autonomous"])
+    p.add_argument("--lr_control_mode", type=str,
+                   choices=["fixed", "autonomous", "none"])
+    p.add_argument("--merge_batch_size", type=int)
+    p.add_argument("--max_analyst_rounds", type=int)
+    p.add_argument("--sel_env_num", type=int)
+    p.add_argument("--test_env_num", type=int)
+    p.add_argument("--eval_test", type=_BOOL)
+    p.add_argument("--use_gate", type=_BOOL)
+    p.add_argument("--max_steps", type=int)
+    p.add_argument("--max_api_workers", type=int)
+    p.add_argument("--analyst_workers", type=int)
+    p.add_argument("--failure_only", type=_BOOL)
+    p.add_argument("--minibatch_size", type=int)
+    p.add_argument("--skill_update_mode", type=str,
+                   choices=[
+                       "patch",
+                       "rewrite_from_suggestions",
+                       "rewrite",
+                       "suggestions",
+                       "full_rewrite",
+                       "full_rewrite_minibatch",
+                       "minibatch_full_rewrite",
+                   ])
+    p.add_argument("--use_slow_update", type=_BOOL)
+    p.add_argument("--slow_update_samples", type=int)
+    p.add_argument("--longitudinal_pair_policy", type=str,
+                   choices=["mixed", "changed", "unchanged"])
+    p.add_argument("--use_meta_skill", type=_BOOL)
+    p.add_argument("--use_skill_aware_reflection", type=_BOOL)
+    p.add_argument("--skill_aware_appendix_source", type=str,
+                   choices=["both", "failure_only"])
+    p.add_argument("--skill_aware_consolidate_threshold", type=int)
+    p.add_argument("--data_path", type=str)
+    p.add_argument("--split_mode", type=str,
+                   choices=["ratio", "split_dir"])
+    p.add_argument("--split_ratio", type=str)
+    p.add_argument("--split_seed", type=int)
+    p.add_argument("--split_dir", type=str)
+    p.add_argument("--split_output_dir", type=str)
+    p.add_argument("--data_root", type=str)
+    p.add_argument("--max_turns", type=int)
+    p.add_argument("--workers", type=int)
+    p.add_argument("--limit", type=int)
+    p.add_argument("--shuffle_choices", type=_BOOL)
+    p.add_argument("--use_theorem", type=_BOOL)
+    p.add_argument("--use_sketch", type=_BOOL)
+    p.add_argument("--image_detail", type=str)
+    p.add_argument("--judge_model", type=str)
+    p.add_argument("--judge_max_completion_tokens", type=int)
+    p.add_argument("--judge_retries", type=int)
+    p.add_argument("--out_root", type=str)
+    p.add_argument("--mode", type=str)
+
+    return p.parse_args()
+
+
+# ── Flat key → structured path mapping (for legacy CLI → structured config) ──
+
+_LEGACY_TO_STRUCTURED: dict[str, str] = {
+    "backend": "model.backend",
+    "optimizer_model": "model.optimizer",
+    "target_model": "model.target",
+    "optimizer_backend": "model.optimizer_backend",
+    "target_backend": "model.target_backend",
+    "reasoning_effort": "model.reasoning_effort",
+    "rewrite_reasoning_effort": "model.rewrite_reasoning_effort",
+    "rewrite_max_completion_tokens": "model.rewrite_max_completion_tokens",
+    "azure_endpoint": "model.azure_endpoint",
+    "azure_api_version": "model.azure_api_version",
+    "azure_api_key": "model.azure_api_key",
+    "azure_openai_endpoint": "model.azure_openai_endpoint",
+    "azure_openai_api_version": "model.azure_openai_api_version",
+    "azure_openai_api_key": "model.azure_openai_api_key",
+    "azure_openai_auth_mode": "model.azure_openai_auth_mode",
+    "azure_openai_ad_scope": "model.azure_openai_ad_scope",
+    "azure_openai_managed_identity_client_id": "model.azure_openai_managed_identity_client_id",
+    "optimizer_azure_openai_endpoint": "model.optimizer_azure_openai_endpoint",
+    "optimizer_azure_openai_api_version": "model.optimizer_azure_openai_api_version",
+    "optimizer_azure_openai_api_key": "model.optimizer_azure_openai_api_key",
+    "optimizer_azure_openai_auth_mode": "model.optimizer_azure_openai_auth_mode",
+    "optimizer_azure_openai_ad_scope": "model.optimizer_azure_openai_ad_scope",
+    "optimizer_azure_openai_managed_identity_client_id": "model.optimizer_azure_openai_managed_identity_client_id",
+    "target_azure_openai_endpoint": "model.target_azure_openai_endpoint",
+    "target_azure_openai_api_version": "model.target_azure_openai_api_version",
+    "target_azure_openai_api_key": "model.target_azure_openai_api_key",
+    "target_azure_openai_auth_mode": "model.target_azure_openai_auth_mode",
+    "target_azure_openai_ad_scope": "model.target_azure_openai_ad_scope",
+    "target_azure_openai_managed_identity_client_id": "model.target_azure_openai_managed_identity_client_id",
+    "qwen_chat_base_url": "model.qwen_chat_base_url",
+    "qwen_chat_api_key": "model.qwen_chat_api_key",
+    "qwen_chat_temperature": "model.qwen_chat_temperature",
+    "qwen_chat_timeout_seconds": "model.qwen_chat_timeout_seconds",
+    "qwen_chat_max_tokens": "model.qwen_chat_max_tokens",
+    "qwen_chat_enable_thinking": "model.qwen_chat_enable_thinking",
+    "optimizer_qwen_chat_base_url": "model.optimizer_qwen_chat_base_url",
+    "optimizer_qwen_chat_api_key": "model.optimizer_qwen_chat_api_key",
+    "optimizer_qwen_chat_temperature": "model.optimizer_qwen_chat_temperature",
+    "optimizer_qwen_chat_timeout_seconds": "model.optimizer_qwen_chat_timeout_seconds",
+    "optimizer_qwen_chat_max_tokens": "model.optimizer_qwen_chat_max_tokens",
+    "optimizer_qwen_chat_enable_thinking": "model.optimizer_qwen_chat_enable_thinking",
+    "target_qwen_chat_base_url": "model.target_qwen_chat_base_url",
+    "target_qwen_chat_api_key": "model.target_qwen_chat_api_key",
+    "target_qwen_chat_temperature": "model.target_qwen_chat_temperature",
+    "target_qwen_chat_timeout_seconds": "model.target_qwen_chat_timeout_seconds",
+    "target_qwen_chat_max_tokens": "model.target_qwen_chat_max_tokens",
+    "target_qwen_chat_enable_thinking": "model.target_qwen_chat_enable_thinking",
+    "minimax_base_url": "model.minimax_base_url",
+    "minimax_api_key": "model.minimax_api_key",
+    "minimax_model": "model.minimax_model",
+    "minimax_temperature": "model.minimax_temperature",
+    "minimax_max_tokens": "model.minimax_max_tokens",
+    "minimax_enable_thinking": "model.minimax_enable_thinking",
+    "codex_exec_path": "model.codex_exec_path",
+    "codex_exec_sandbox": "model.codex_exec_sandbox",
+    "codex_exec_profile": "model.codex_exec_profile",
+    "codex_exec_full_auto": "model.codex_exec_full_auto",
+    "codex_exec_reasoning_effort": "model.codex_exec_reasoning_effort",
+    "codex_exec_use_sdk": "model.codex_exec_use_sdk",
+    "codex_exec_network_access": "model.codex_exec_network_access",
+    "codex_exec_web_search": "model.codex_exec_web_search",
+    "codex_exec_approval_policy": "model.codex_exec_approval_policy",
+    "claude_code_exec_path": "model.claude_code_exec_path",
+    "claude_code_exec_profile": "model.claude_code_exec_profile",
+    "claude_code_exec_use_sdk": "model.claude_code_exec_use_sdk",
+    "claude_code_exec_effort": "model.claude_code_exec_effort",
+    "claude_code_exec_max_thinking_tokens": "model.claude_code_exec_max_thinking_tokens",
+    "codex_trace_to_optimizer": "model.codex_trace_to_optimizer",
+    "num_epochs": "train.num_epochs",
+    "train_size": "train.train_size",
+    "steps_per_epoch": "train.steps_per_epoch",
+    "batch_size": "train.batch_size",
+    "accumulation": "train.accumulation",
+    "seed": "train.seed",
+    "minibatch_size": "gradient.minibatch_size",
+    "merge_batch_size": "gradient.merge_batch_size",
+    "analyst_workers": "gradient.analyst_workers",
+    "max_analyst_rounds": "gradient.max_analyst_rounds",
+    "failure_only": "gradient.failure_only",
+    "edit_budget": "optimizer.learning_rate",
+    "min_edit_budget": "optimizer.min_learning_rate",
+    "lr_scheduler": "optimizer.lr_scheduler",
+    "lr_control_mode": "optimizer.lr_control_mode",
+    "skill_update_mode": "optimizer.skill_update_mode",
+    "use_slow_update": "optimizer.use_slow_update",
+    "slow_update_samples": "optimizer.slow_update_samples",
+    "longitudinal_pair_policy": "optimizer.longitudinal_pair_policy",
+    "use_meta_skill": "optimizer.use_meta_skill",
+    "use_skill_aware_reflection": "optimizer.use_skill_aware_reflection",
+    "skill_aware_appendix_source": "optimizer.skill_aware_appendix_source",
+    "skill_aware_consolidate_threshold": "optimizer.skill_aware_consolidate_threshold",
+    "use_gate": "evaluation.use_gate",
+    "sel_env_num": "evaluation.sel_env_num",
+    "test_env_num": "evaluation.test_env_num",
+    "eval_test": "evaluation.eval_test",
+    "env": "env.name",
+    "skill_init": "env.skill_init",
+    "out_root": "env.out_root",
+}
+
+
+def load_config(args: argparse.Namespace) -> dict:
+    """Load config with _base_ inheritance, then apply CLI overrides."""
+    from skillopt.config import load_config as _load, flatten_config, is_structured
+
+    cfg = _load(args.config, overrides=args.cfg_options)
+    structured = is_structured(cfg)
+
+    # Apply legacy --key value overrides
+    cli = {k: v for k, v in vars(args).items()
+           if v is not None and k not in ("config", "cfg_options")}
+    if cli:
+        if structured:
+            from skillopt.config import apply_overrides
+            mapped = []
+            for k, v in cli.items():
+                dotted = _LEGACY_TO_STRUCTURED.get(k)
+                if dotted:
+                    mapped.append(f"{dotted}={v}")
+                else:
+                    mapped.append(f"env.{k}={v}")
+            apply_overrides(cfg, mapped)
+        else:
+            cfg.update(cli)
+
+    # Flatten structured config → flat dict for trainer/adapter
+    flat = flatten_config(cfg) if structured else cfg
+
+    for new_key, old_key in (
+        ("azure_openai_endpoint", "azure_endpoint"),
+        ("azure_openai_api_version", "azure_api_version"),
+        ("azure_openai_api_key", "azure_api_key"),
+    ):
+        if flat.get(new_key) in (None, "") and flat.get(old_key) not in (None, ""):
+            flat[new_key] = flat[old_key]
+
+    explicit_backend = getattr(args, "backend", None)
+    if explicit_backend is None:
+        for option in args.cfg_options or []:
+            key = str(option).split("=", 1)[0].strip()
+            if key == "model.backend":
+                explicit_backend = str(option).split("=", 1)[1].strip()
+                break
+
+    backend = normalize_backend_name(flat.get("model_backend") or flat.get("target_backend") or "azure_openai")
+
+    def _has_model_override(dotted_key: str, legacy_key: str) -> bool:
+        if getattr(args, legacy_key, None) is not None:
+            return True
+        for option in args.cfg_options or []:
+            key = str(option).split("=", 1)[0].strip()
+            if key == dotted_key:
+                return True
+        return False
+
+    if explicit_backend is not None:
+        backend = normalize_backend_name(explicit_backend)
+        flat["model_backend"] = backend
+        if backend in {"claude", "claude_chat"}:
+            flat.setdefault("optimizer_backend", "claude_chat")
+            flat.setdefault("target_backend", "claude_chat")
+        elif backend in {"codex", "codex_exec"}:
+            flat.setdefault("optimizer_backend", "openai_chat")
+            flat.setdefault("target_backend", "codex_exec")
+        elif backend == "claude_code_exec":
+            flat.setdefault("optimizer_backend", "openai_chat")
+            flat.setdefault("target_backend", "claude_code_exec")
+        elif backend in {"qwen", "qwen_chat"}:
+            flat.setdefault("optimizer_backend", "openai_chat")
+            flat.setdefault("target_backend", "qwen_chat")
+        elif backend in {"minimax", "minimax_chat"}:
+            flat.setdefault("optimizer_backend", "openai_chat")
+            flat.setdefault("target_backend", "minimax_chat")
+        else:
+            flat.setdefault("optimizer_backend", "openai_chat")
+            flat.setdefault("target_backend", "openai_chat")
+    else:
+        flat.setdefault("optimizer_backend", "openai_chat")
+        flat.setdefault("target_backend", "openai_chat")
+
+    if flat.get("optimizer_backend") == "claude_chat":
+        if (
+            str(flat.get("optimizer_model", "") or "").strip() in _OPENAI_DEFAULT_MODEL_SENTINELS
+            and not _has_model_override("model.optimizer", "optimizer_model")
+        ):
+            flat["optimizer_model"] = default_model_for_backend("claude_chat")
+    if flat.get("optimizer_backend") == "qwen_chat":
+        if (
+            str(flat.get("optimizer_model", "") or "").strip() in _OPENAI_DEFAULT_MODEL_SENTINELS
+            and not _has_model_override("model.optimizer", "optimizer_model")
+        ):
+            flat["optimizer_model"] = default_model_for_backend("qwen_chat")
+    if flat.get("target_backend") == "claude_chat":
+        if (
+            str(flat.get("target_model", "") or "").strip() in _OPENAI_DEFAULT_MODEL_SENTINELS
+            and not _has_model_override("model.target", "target_model")
+        ):
+            flat["target_model"] = default_model_for_backend("claude_chat")
+    if flat.get("target_backend") == "claude_code_exec":
+        if (
+            str(flat.get("target_model", "") or "").strip() in _OPENAI_DEFAULT_MODEL_SENTINELS
+            and not _has_model_override("model.target", "target_model")
+        ):
+            flat["target_model"] = default_model_for_backend("claude_chat")
+    if flat.get("target_backend") == "qwen_chat":
+        if (
+            str(flat.get("target_model", "") or "").strip() in _OPENAI_DEFAULT_MODEL_SENTINELS
+            and not _has_model_override("model.target", "target_model")
+        ):
+            flat["target_model"] = default_model_for_backend("qwen_chat")
+    if flat.get("target_backend") == "minimax_chat":
+        if (
+            str(flat.get("target_model", "") or "").strip() in _OPENAI_DEFAULT_MODEL_SENTINELS
+            and not _has_model_override("model.target", "target_model")
+        ):
+            flat["target_model"] = (
+                flat.get("minimax_model")
+                or default_model_for_backend("minimax_chat")
+            )
+
+    # Auto-generate output root
+    if not flat.get("out_root"):
+        env = flat.get("env", "unknown")
+        model = flat.get("optimizer_model", "unknown").replace("/", "-")
+        ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        flat["out_root"] = os.path.join("outputs", f"skillopt_{env}_{model}_{ts}")
+
+    flat["out_root"] = os.path.abspath(flat["out_root"])
+    return flat
+
+
+# ── Main ─────────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    args = parse_args()
+    cfg = load_config(args)
+
+    print(f"\n{'='*60}")
+    print(f"  SkillOpt — Executive Strategy for Self-Evolving Agent Skills")
+    print(f"{'='*60}")
+    print(f"  env:            {cfg.get('env')}")
+    print(f"  optimizer_model:  {cfg.get('optimizer_model')}")
+    print(f"  target_model:  {cfg.get('target_model')}")
+    print(f"  optimizer_backend:{cfg.get('optimizer_backend', 'openai_chat')}")
+    print(f"  target_backend:{cfg.get('target_backend', 'openai_chat')}")
+    print(f"  reasoning:      {cfg.get('reasoning_effort') or 'off'}")
+    print(f"  rewrite_effort: {cfg.get('rewrite_reasoning_effort') or 'off'}")
+    print(f"  epochs:         {cfg.get('num_epochs')}")
+    print(f"  train_size:     {cfg.get('train_size') or 'from dataset'}")
+    print(f"  steps/epoch:    auto")
+    print(f"  batch_size:     {cfg.get('batch_size')}")
+    print(f"  edit_budget:    {cfg.get('edit_budget')}")
+    print(f"  lr_scheduler:   {cfg.get('lr_scheduler', 'constant')}")
+    print(f"  update_mode:    {cfg.get('skill_update_mode', 'patch')}")
+    print(f"  min_edit_budget:{cfg.get('min_edit_budget', 2)}")
+    print(f"  minibatch_size: {cfg.get('minibatch_size')}")
+    print(f"  seed:           {cfg.get('seed')}")
+    print(f"  meta_skill:     {cfg.get('use_meta_skill', False)}")
+    print(f"  skill_aware_reflection: {cfg.get('use_skill_aware_reflection', False)}")
+    print(f"  slow_update:    {cfg.get('use_slow_update', False)}")
+    print(f"  out_root:       {cfg.get('out_root')}")
+    print(f"{'='*60}\n")
+
+    # Build adapter
+    adapter = get_adapter(cfg)
+
+    # Build trainer and run
+    from skillopt.engine.trainer import ReflACTTrainer
+    trainer = ReflACTTrainer(cfg, adapter)
+    summary = trainer.train()
+
+    print(f"\n  Output saved to: {cfg['out_root']}")
+    if summary.get("test_hard") is not None:
+        print(f"  Final test: {summary['test_hard']:.4f}")
+
+
+if __name__ == "__main__":
+    main()

package/template/skills/ponytail/SKILL.md

@@ -1,117 +0,0 @@
----
-name: ponytail
-description: >
-  Forces the laziest solution that actually works, simplest, shortest, most
-  minimal. Channels a senior dev who has seen everything: question whether the
-  task needs to exist at all (YAGNI), reach for the standard library before
-  custom code, native platform features before dependencies, one line before
-  fifty. Supports intensity levels: lite, full (default), ultra. Use whenever
-  the user says "ponytail", "be lazy", "lazy mode", "simplest solution",
-  "minimal solution", "yagni", "do less", or "shortest path", and whenever
-  they complain about over-engineering, bloat, boilerplate, or unnecessary
-  dependencies.
-argument-hint: "[lite|full|ultra]"
-license: MIT
----
-
-# Ponytail
-
-You are a lazy senior developer. Lazy means efficient, not careless. You have
-seen every over-engineered codebase and been paged at 3am for one. The best
-code is the code never written.
-
-## Persistence
-
-ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if
-unsure. Off only: "stop ponytail" / "normal mode". Default: **full**.
-Switch: `/ponytail lite|full|ultra`.
-
-## The ladder
-
-Stop at the first rung that holds:
-
-1. **Does this need to exist at all?** Speculative need = skip it, say so in one line. (YAGNI)
-2. **Already in this codebase?** A helper, util, type, or pattern that already lives here → reuse it. Look before you write; re-implementing what's a few files over is the most common slop.
-3. **Stdlib does it?** Use it.
-4. **Native platform feature covers it?** `<input type="date">` over a picker lib, CSS over JS, DB constraint over app code.
-5. **Already-installed dependency solves it?** Use it. Never add a new one for what a few lines can do.
-6. **Can it be one line?** One line.
-7. **Only then:** the minimum code that works.
-
-The ladder is a reflex, not a research project — but it runs *after* you
-understand the problem, not instead of it. Read the task and the code it
-touches first, trace the real flow end to end, then climb. Two rungs work →
-take the higher one and move on. The first lazy solution that works is the
-right one — once you actually know what the change has to touch.
-
-**Bug fix = root cause, not symptom.** A report names a symptom. Before you
-edit, grep every caller of the function you're about to touch. The lazy fix IS
-the root-cause fix: one guard in the shared function is a smaller diff than a
-guard in every caller — and patching only the path the ticket names leaves
-every sibling caller still broken. Fix it once, where all callers route through.
-
-## Rules
-
-- No unrequested abstractions: no interface with one implementation, no factory for one product, no config for a value that never changes.
-- No boilerplate, no scaffolding "for later", later can scaffold for itself.
-- Deletion over addition. Boring over clever, clever is what someone decodes at 3am.
-- Fewest files possible. Shortest working diff wins — but only once you understand the problem. The smallest change in the wrong place isn't lazy, it's a second bug.
-- Complex request? Ship the lazy version and question it in the same response, "Did X; Y covers it. Need full X? Say so." Never stall on an answer you can default.
-- Two stdlib options, same size? Take the one that's correct on edge cases. Lazy means writing less code, not picking the flimsier algorithm.
-- Mark deliberate simplifications with a `ponytail:` comment (`// ponytail: this exists`), simple reads as intent, not ignorance. Shortcut with a known ceiling (global lock, O(n²) scan, naive heuristic)? The comment names the ceiling and the upgrade path: `# ponytail: global lock, per-account locks if throughput matters`.
-
-## Output
-
-Code first. Then at most three short lines: what was skipped, when to add it.
-No essays, no feature tours, no design notes. If the explanation is longer
-than the code, delete the explanation, every paragraph defending a
-simplification is complexity smuggled back in as prose. Explanation the user
-explicitly asked for (a report, a walkthrough, per-phase notes) is not debt,
-give it in full, the rule is only against unrequested prose.
-
-Pattern: `[code] → skipped: [X], add when [Y].`
-
-## Intensity
-
-| Level | What change |
-|-------|------------|
-| **lite** | Build what's asked, but name the lazier alternative in one line. User picks. |
-| **full** | The ladder enforced. Stdlib and native first. Shortest diff, shortest explanation. Default. |
-| **ultra** | YAGNI extremist. Deletion before addition. Ship the one-liner and challenge the rest of the requirement in the same breath. |
-
-Example: "Add a cache for these API responses."
-- lite: "Done, cache added. FYI: `functools.lru_cache` covers this in one line if you'd rather not own a cache class."
-- full: "`@lru_cache(maxsize=1000)` on the fetch function. Skipped custom cache class, add when lru_cache measurably falls short."
-- ultra: "No cache until a profiler says so. When it does: `@lru_cache`. A hand-rolled TTL cache class is a bug farm with a hit rate."
-
-## When NOT to be lazy
-
-Never simplify away: input validation at trust boundaries, error handling
-that prevents data loss, security measures, accessibility basics, anything
-explicitly requested. User insists on the full version → build it, no
-re-arguing.
-
-Never lazy about understanding the problem. The ladder shortens the
-solution, never the reading. Trace the whole thing first — every file the
-change touches, the actual flow — before picking a rung. Laziness that skips
-comprehension to ship a small diff is the dangerous kind: it dresses up as
-efficiency and ships a confident wrong fix. Read fully, then be lazy.
-
-Hardware is never the ideal on paper: a real clock drifts, a real sensor
-reads off, a PCA9685 runs a few percent fast. Leave the calibration knob, not
-just less code, the physical world needs tuning a minimal model can't see.
-
-Lazy code without its check is unfinished. Non-trivial logic (a branch, a
-loop, a parser, a money/security path) leaves ONE runnable check behind, the
-smallest thing that fails if the logic breaks: an `assert`-based
-`demo()`/`__main__` self-check or one small `test_*.py`. No frameworks, no
-fixtures, no per-function suites unless asked. Trivial one-liners need no
-test, YAGNI applies to tests too.
-
-## Boundaries
-
-Ponytail governs what you build, not how you talk (pair with Caveman for
-terse prose). "stop ponytail" / "normal mode": revert. Level persists until
-changed or session end.
-
-The shortest path to done is the right path.