self-evolve-framework 1.6.0 → 1.6.1

package/template/skills/skillopt-sleep/scripts/framework/skillopt/optimizer/skill.py

@@ -1,201 +0,0 @@
-"""ReflACT skill operations — edit application and patch processing.
-
-The Update stage (⑤) of the ReflACT pipeline: apply a ranked set of
-edits to the current skill document, producing an updated candidate.
-Analogous to optimizer.step() in neural network training.
-"""
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from skillopt.types import Edit as EditType, Patch as PatchType
-
-SLOW_UPDATE_START = "<!-- SLOW_UPDATE_START -->"
-SLOW_UPDATE_END = "<!-- SLOW_UPDATE_END -->"
-
-# Skill-aware reflection (EmbodiSkill S_app) appendix region. Like the slow
-# update region, it is protected: step-level analyst edits must not modify it.
-APPENDIX_START = "<!-- APPENDIX_START -->"
-APPENDIX_END = "<!-- APPENDIX_END -->"
-
-# All protected (start, end) marker pairs. Step-level edits cannot target text
-# inside any of these regions, and `append` / `insert_after`-fallback ops are
-# inserted before the earliest-occurring region so protected blocks stay at the
-# document tail. With only the slow-update region present, every helper reduces
-# to the original slow-update-only behavior (byte-identical skill output).
-_PROTECTED_REGIONS: tuple[tuple[str, str], ...] = (
-    (SLOW_UPDATE_START, SLOW_UPDATE_END),
-    (APPENDIX_START, APPENDIX_END),
-)
-
-
-def _earliest_protected_start(skill: str) -> int:
-    """Index of the earliest protected-region start marker, or -1 if none."""
-    positions = [
-        idx
-        for idx in (skill.find(start) for start, _ in _PROTECTED_REGIONS)
-        if idx != -1
-    ]
-    return min(positions) if positions else -1
-
-
-def _is_in_protected_region(skill: str, target: str) -> bool:
-    """Check if *target* text falls within any protected region."""
-    if not target:
-        return False
-    target_idx = skill.find(target)
-    if target_idx == -1:
-        return False
-    for start_marker, end_marker in _PROTECTED_REGIONS:
-        start_idx = skill.find(start_marker)
-        end_idx = skill.find(end_marker)
-        if start_idx == -1 or end_idx == -1:
-            continue
-        region_end = end_idx + len(end_marker)
-        if start_idx <= target_idx < region_end:
-            return True
-    return False
-
-
-def _is_in_slow_update_region(skill: str, target: str) -> bool:
-    """Backward-compatible alias kept for any external callers/tests."""
-    return _is_in_protected_region(skill, target)
-
-
-def _strip_slow_update_markers(text: str) -> str:
-    """Remove any protected-region markers from edit content to prevent duplication."""
-    return (
-        text.replace(SLOW_UPDATE_START, "")
-            .replace(SLOW_UPDATE_END, "")
-            .replace(APPENDIX_START, "")
-            .replace(APPENDIX_END, "")
-    )
-
-
-def _edit_fields(edit: EditType | dict) -> tuple[str, str, str]:
-    op = edit.op if hasattr(edit, "op") else edit.get("op", "")
-    content = _strip_slow_update_markers(
-        (edit.content if hasattr(edit, "content") else edit.get("content", "")).strip()
-    )
-    target = edit.target if hasattr(edit, "target") else edit.get("target", "")
-    return op, content, target
-
-
-def _apply_edit_with_report(skill: str, edit: EditType | dict) -> tuple[str, dict]:
-    op, content, target = _edit_fields(edit)
-    report = {
-        "op": op,
-        "target": target[:200],
-        "content_preview": content[:200],
-        "status": "unknown",
-    }
-
-    if target and _is_in_protected_region(skill, target):
-        report["status"] = "skipped_protected_region"
-        return skill, report
-
-    if op == "append":
-        prot_start = _earliest_protected_start(skill)
-        if prot_start != -1:
-            before = skill[:prot_start].rstrip()
-            after = skill[prot_start:]
-            report["status"] = "applied_append_before_protected_region"
-            return before + "\n\n" + content + "\n\n" + after, report
-        report["status"] = "applied_append"
-        return skill.rstrip() + "\n\n" + content + "\n", report
-
-    if op == "insert_after":
-        if not target or target not in skill:
-            prot_start = _earliest_protected_start(skill)
-            if prot_start != -1:
-                before = skill[:prot_start].rstrip()
-                after = skill[prot_start:]
-                report["status"] = "applied_insert_after_fallback_before_protected_region"
-                return before + "\n\n" + content + "\n\n" + after, report
-            report["status"] = "applied_insert_after_fallback_append"
-            return skill.rstrip() + "\n\n" + content + "\n", report
-        idx = skill.index(target) + len(target)
-        newline = skill.find("\n", idx)
-        insert_at = newline + 1 if newline != -1 else len(skill)
-        report["status"] = "applied_insert_after"
-        return skill[:insert_at] + "\n" + content + "\n" + skill[insert_at:], report
-
-    if op == "replace":
-        if not target:
-            report["status"] = "skipped_replace_missing_target"
-            return skill, report
-        if target not in skill:
-            report["status"] = "skipped_replace_target_not_found"
-            return skill, report
-        report["status"] = "applied_replace"
-        return skill.replace(target, content, 1), report
-
-    if op == "delete":
-        if not target:
-            report["status"] = "skipped_delete_missing_target"
-            return skill, report
-        if target not in skill:
-            report["status"] = "skipped_delete_target_not_found"
-            return skill, report
-        report["status"] = "applied_delete"
-        return skill.replace(target, "", 1), report
-
-    report["status"] = "skipped_unknown_op"
-    return skill, report
-
-
-def apply_edit(skill: str, edit: EditType | dict) -> str:
-    """Apply a single edit operation to the skill document.
-
-    Parameters
-    ----------
-    skill : str
-        Current skill document content.
-    edit : Edit | dict
-        An :class:`~skillopt.types.Edit` instance or a plain dict with
-        keys ``op``, ``content``, ``target``.
-
-    Edits targeting the protected slow-update region are silently skipped.
-    """
-    updated_skill, _ = _apply_edit_with_report(skill, edit)
-    return updated_skill
-
-
-def apply_patch_with_report(
-    skill: str,
-    patch: PatchType | dict,
-) -> tuple[str, list[dict]]:
-    """Apply a patch and return a per-edit report for observability."""
-    edits = patch.edits if hasattr(patch, "edits") else patch.get("edits", [])
-    reports: list[dict] = []
-    for idx, edit in enumerate(edits, 1):
-        try:
-            skill, report = _apply_edit_with_report(skill, edit)
-            report["index"] = idx
-        except Exception as exc:  # noqa: BLE001
-            report = {
-                "index": idx,
-                "op": "",
-                "target": "",
-                "content_preview": "",
-                "status": "error",
-                "error": str(exc),
-            }
-        reports.append(report)
-    return skill, reports
-
-
-def apply_patch(skill: str, patch: PatchType | dict) -> str:
-    """Apply a patch (list of edits) to the skill document sequentially.
-
-    Parameters
-    ----------
-    skill : str
-        Current skill document content.
-    patch : Patch | dict
-        A :class:`~skillopt.types.Patch` instance or a plain dict with
-        key ``edits`` containing a list of edit operations.
-    """
-    updated_skill, _ = apply_patch_with_report(skill, patch)
-    return updated_skill

package/template/skills/skillopt-sleep/scripts/framework/skillopt/optimizer/skill_aware.py

@@ -1,206 +0,0 @@
-"""Skill-Aware Reflection — analyst prompt augmentation (EmbodiSkill).
-
-When ``use_skill_aware_reflection`` is enabled, the failure/success analysts are
-asked to additionally classify each reflection by EmbodiSkill type and to route
-**EXECUTION_LAPSE** reflections (the skill rule is correct, the executor just
-failed to follow it) into a separate ``appendix_notes`` list instead of the body
-patch. This module owns:
-
-1. the instruction text appended to the resolved analyst system prompt, and
-2. extraction of ``appendix_notes`` from the analyst JSON response.
-
-Design notes
-------------
-- The suffix is appended **at runtime, gated by the toggle**, so env-specific and
-  generic analyst prompts are augmented uniformly and — when the toggle is off —
-  remain byte-identical to baseline.
-- Discrimination follows the paper / GMemory: ``SKILL_DEFECT`` = the skill rule is
-  wrong / missing / underspecified (→ body edit); ``EXECUTION_LAPSE`` = the rule
-  is valid but the agent didn't follow it (→ appendix reminder, body untouched).
-  **When unsure, default to EXECUTION_LAPSE** (protect the body — never delete a
-  valid rule over a one-off execution slip).
-- Success reflections are labeled DISCOVERY / OPTIMIZATION for logging only; their
-  edit behavior is unchanged.
-"""
-from __future__ import annotations
-
-
-# ── Runtime switch (config-driven, env-independent) ─────────────────────────
-#
-# The trainer calls :func:`configure_skill_aware_reflection` once at startup
-# from the resolved config. ``run_minibatch_reflect`` then picks these values
-# up automatically, so env adapters never need to thread the toggle through —
-# the feature is controlled purely by ``optimizer.use_skill_aware_reflection``
-# regardless of benchmark. Mirrors the ``configure_azure_openai`` pattern in
-# :mod:`skillopt.model`. Explicit kwargs at a call site still take precedence
-# (backward compatible).
-
-_RUNTIME: dict = {"enabled": False, "appendix_source": "both"}
-
-
-def configure_skill_aware_reflection(
-    enabled: bool,
-    appendix_source: str = "both",
-) -> None:
-    """Set the process-wide skill-aware reflection switch from config."""
-    _RUNTIME["enabled"] = bool(enabled)
-    _RUNTIME["appendix_source"] = str(appendix_source or "both")
-
-
-def is_skill_aware_enabled() -> bool:
-    return bool(_RUNTIME["enabled"])
-
-
-def get_skill_aware_appendix_source() -> str:
-    return str(_RUNTIME["appendix_source"])
-
-
-# ── Prompt suffixes ─────────────────────────────────────────────────────────
-
-# Appended to the FAILURE analyst system prompt when the toggle is on.
-ERROR_SUFFIX = """
-
-## Skill-Aware Reflection (EmbodiSkill)
-
-Before proposing body edits, classify EACH failure pattern as one of:
-
-- **SKILL_DEFECT**: the current skill is wrong, missing, or underspecified for
-  this situation — i.e. an agent that *followed the skill* would still fail, or
-  the skill gives no relevant guidance. These become normal body `edits`.
-- **EXECUTION_LAPSE**: the skill ALREADY contains a relevant, correct rule that
-  would have avoided the failure, but the agent did not follow it (e.g. ignored a
-  rule, malformed output, copied the feedback text verbatim, emitted a non-action
-  token like "stop", or otherwise broke execution unrelated to skill content).
-
-Discrimination test: "Is there a rule in the current skill that, if followed,
-prevents this failure?" If yes → EXECUTION_LAPSE. If no (rule absent/wrong) →
-SKILL_DEFECT. **When genuinely unsure, choose EXECUTION_LAPSE** — do not edit or
-delete a valid rule over a one-off execution slip.
-
-Routing:
-- SKILL_DEFECT → put the fix in `patch.edits` (body), as usual.
-- EXECUTION_LAPSE → put a concise reminder in `appendix_notes` (a flat list of
-  strings). DO NOT add a body edit for it. Each note should re-emphasize the
-  existing valid rule the agent failed to follow; it must NOT introduce a new
-  rule. Keep notes short, concrete, and reusable.
-
-Add `appendix_notes` as a TOP-LEVEL key of your JSON output (a sibling of
-`patch`), e.g. `"appendix_notes": ["Follow the existing X rule before Y."]`.
-Use `[]` when there is no execution lapse. Body edits and appendix notes are
-independent: a batch may yield only edits, only notes, both, or neither.
-"""
-
-# Appended to the SUCCESS analyst system prompt when the toggle is on.
-SUCCESS_SUFFIX = """
-
-## Skill-Aware Reflection (EmbodiSkill)
-
-For each proposed edit, optionally label its `reflection_type` for logging:
-- **DISCOVERY**: a useful new rule not yet in the skill (typically an `append`).
-- **OPTIMIZATION**: a better way to perform an existing rule (typically a
-  `replace` of that rule).
-
-This labeling does not change edit behavior. You may also add a top-level
-`appendix_notes` list (flat strings) if a successful trajectory reveals an
-existing valid rule worth re-emphasizing; otherwise use `[]`.
-"""
-
-
-def augment_error_prompt(system_prompt: str) -> str:
-    """Append the failure-analyst skill-aware instruction."""
-    return system_prompt.rstrip() + "\n" + ERROR_SUFFIX
-
-
-def augment_success_prompt(system_prompt: str) -> str:
-    """Append the success-analyst skill-aware instruction."""
-    return system_prompt.rstrip() + "\n" + SUCCESS_SUFFIX
-
-
-# ── Response parsing ────────────────────────────────────────────────────────
-
-
-def extract_appendix_notes(result: dict | None) -> list[str]:
-    """Pull a clean list of appendix-note strings from an analyst JSON result.
-
-    Tolerant of shape: accepts a top-level ``appendix_notes`` list, a single
-    string, or items wrapped in dicts with a ``note``/``content`` field. Returns
-    ``[]`` for anything missing or malformed (so a non-compliant model degrades
-    gracefully to baseline body-only behavior).
-    """
-    if not isinstance(result, dict):
-        return []
-    raw = result.get("appendix_notes")
-    if raw is None:
-        return []
-    if isinstance(raw, str):
-        raw = [raw]
-    if not isinstance(raw, list):
-        return []
-    notes: list[str] = []
-    for item in raw:
-        if isinstance(item, str):
-            text = item.strip()
-        elif isinstance(item, dict):
-            text = str(item.get("note") or item.get("content") or "").strip()
-        else:
-            text = ""
-        if text:
-            notes.append(text)
-    return notes
-
-
-# ── Appendix consolidation (threshold-gated, paper Eq.11 UpdateSkillAppendix) ──
-
-_CONSOLIDATE_SYSTEM = (
-    "You compact the Execution Notes Appendix of an agent skill. Each note "
-    "re-emphasizes an existing skill rule the agent failed to follow. Your job "
-    "is a periodic compaction pass: remove duplicates and redundant overlap, "
-    "merge near-identical reminders into one, and simplify phrasing while keeping "
-    "each note concrete and operational. Do not invent new rules. Preserve the "
-    "distinct actionable content. Return valid JSON only."
-)
-
-
-def consolidate_appendix_notes(
-    notes: list[str],
-    *,
-    chat_fn,
-    max_completion_tokens: int = 4096,
-) -> list[str]:
-    """LLM-consolidate appendix notes: dedupe / merge / compact.
-
-    Mirrors GMemory ``_maybe_refactor_execution_notes`` and paper Eq.11. ``chat_fn``
-    is the optimizer chat callable ``(system, user, max_completion_tokens, retries,
-    stage) -> (text, meta)``. On ANY failure (parse, empty, exception) the original
-    notes are returned unchanged, so consolidation can never lose the appendix.
-    """
-    from skillopt.utils import extract_json  # local import to avoid cycles
-
-    clean = [str(n).strip() for n in (notes or []) if str(n).strip()]
-    if len(clean) < 2:
-        return clean
-
-    numbered = "\n".join(f"{i}. {n}" for i, n in enumerate(clean, 1))
-    user = (
-        f"## Current Execution Notes ({len(clean)} total)\n{numbered}\n\n"
-        "Compact these into a shorter list without losing distinct actionable "
-        "information. Merge duplicates and near-duplicates; keep each note short, "
-        "concrete, and reusable. Return valid JSON only with this schema:\n"
-        '{ "appendix_notes": ["compacted note 1", "compacted note 2"] }'
-    )
-    try:
-        response, _ = chat_fn(
-            system=_CONSOLIDATE_SYSTEM,
-            user=user,
-            max_completion_tokens=max_completion_tokens,
-            retries=2,
-            stage="appendix_consolidate",
-        )
-        result = extract_json(response)
-        compacted = extract_appendix_notes(result)
-        # Guard: only accept a non-empty result that actually shrinks the set.
-        if compacted and len(compacted) <= len(clean):
-            return compacted
-    except Exception:  # noqa: BLE001
-        pass
-    return clean