self-evolve-framework 1.4.0 → 1.6.0

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

@@ -0,0 +1,201 @@
+"""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

@@ -0,0 +1,206 @@
+"""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