release: publish csep 1.3.9

Author: T0UGH

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "csep"
-version = "1.3.8"
+version = "1.3.9"
 description = "Self-evolution loop for OpenAI Codex: session reflection, session recall, and reflection-generated skills with zero Python runtime dependencies."
 readme = "README.md"
 requires-python = ">=3.11"

src/codex_self_evolution/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "1.3.8"
+__version__ = "1.3.9"

src/codex_self_evolution/session_reflection/runner.py

@@ -41,6 +41,12 @@
 
 RECEIPT_POLL_INTERVAL_SECONDS = 0.05
 RECEIPT_STABLE_INVALID_GRACE_SECONDS = 0.5
+VALIDATION_ISSUE_KEYS = (
+    "boundary_violations",
+    "hash_mismatches",
+    "invalid_skills",
+    "low_value_memory_writes",
+)
 
 
 def enqueue_reflection_from_payload(payload: dict[str, Any], *, home: str | Path | None = None) -> dict[str, Any]:
@@ -272,9 +278,45 @@ def _compact_validation(validation: dict[str, Any]) -> dict[str, Any]:
         value = validation.get(key)
         if value is not None:
             compact[key] = value
+    category = _validation_category(validation)
+    if category:
+        compact["category"] = category
+        compact["issue_counts"] = _validation_issue_counts(validation)
     return compact
 
 
+def _validation_category(validation: dict[str, Any]) -> str:
+    """Classify validation failures by whether receipt or artifacts broke."""
+    status = str(validation.get("status") or "")
+    if status not in {"failed", "partial"}:
+        return ""
+    reason = str(validation.get("reason") or "")
+    if reason.startswith("receipt_") or reason in {
+        "missing_receipt",
+        "job_id_mismatch",
+        "parent_session_id_mismatch",
+        "child_thread_id_mismatch",
+    }:
+        return "child_receipt_contract"
+    if validation.get("boundary_violations"):
+        return "child_artifact_boundary"
+    if validation.get("hash_mismatches") or validation.get("invalid_skills") or validation.get("low_value_memory_writes"):
+        return "child_artifact_quality"
+    if validation.get("error"):
+        return "system_error"
+    return "child_validation"
+
+
+def _validation_issue_counts(validation: dict[str, Any]) -> dict[str, int]:
+    """Return compact counts for validation issue lists present in status."""
+    if not any(key in validation for key in VALIDATION_ISSUE_KEYS):
+        return {}
+    return {
+        key: len(value) if isinstance(value := validation.get(key), list) else 0
+        for key in VALIDATION_ISSUE_KEYS
+    }
+
+
 def _wait_for_receipt(receipt_path: Path, *, timeout_seconds: float) -> None:
     """Wait for an asynchronous app-server turn to finish writing its receipt."""
     deadline = time.monotonic() + max(0.0, timeout_seconds)
@@ -381,13 +423,66 @@ def _load_receipt_object(receipt_path: Path) -> tuple[dict[str, Any] | None, str
         return None, f"receipt_unreadable: {exc}"
     if not text.strip():
         return None, "receipt_empty"
-    try:
-        loaded = json.loads(text)
-    except ValueError as exc:
-        return None, f"receipt_invalid_json: {exc}"
-    if not isinstance(loaded, dict):
+    receipt, parse_error = _parse_receipt_object_text(text)
+    if receipt is None:
+        return None, f"receipt_invalid_json: {parse_error}"
+    if not isinstance(receipt, dict):
         return None, "receipt_not_object"
-    return loaded, ""
+    return receipt, ""
+
+
+def _parse_receipt_object_text(text: str) -> tuple[dict[str, Any] | None, str]:
+    """Parse common model-written receipt variants into a receipt object."""
+    last_error = ""
+    for candidate in _receipt_text_candidates(text):
+        try:
+            loaded = json.loads(candidate)
+        except ValueError as exc:
+            last_error = str(exc)
+            continue
+        if isinstance(loaded, dict):
+            return loaded, ""
+        if isinstance(loaded, str):
+            try:
+                nested = json.loads(loaded)
+            except ValueError as exc:
+                last_error = str(exc)
+                continue
+            if isinstance(nested, dict):
+                return nested, ""
+    return None, last_error or "not a JSON object"
+
+
+def _receipt_text_candidates(text: str) -> list[str]:
+    """Return raw, fenced, and escaped receipt text candidates."""
+    stripped = text.strip()
+    candidates = [stripped]
+    unfenced = _strip_json_code_fence(stripped)
+    if unfenced != stripped:
+        candidates.append(unfenced)
+    for base in list(candidates):
+        decoded = _decode_escaped_receipt_text(base)
+        if decoded and decoded not in candidates:
+            candidates.append(decoded)
+    return candidates
+
+
+def _strip_json_code_fence(text: str) -> str:
+    """Remove a surrounding Markdown JSON code fence from receipt text."""
+    lines = text.splitlines()
+    if len(lines) >= 3 and lines[0].strip().startswith("```") and lines[-1].strip() == "```":
+        return "\n".join(lines[1:-1]).strip()
+    return text
+
+
+def _decode_escaped_receipt_text(text: str) -> str:
+    """Decode receipt text that escaped quotes/newlines without string quotes."""
+    if "\\\"" not in text and "\\n" not in text:
+        return ""
+    try:
+        return text.encode("utf-8").decode("unicode_escape")
+    except UnicodeError:
+        return ""
 
 
 def _canonicalize_receipt_envelope(

tests/test_session_reflection_runner.py

@@ -437,6 +437,51 @@ def test_run_reflection_job_recovers_changed_memory_when_receipt_is_invalid(
     assert receipt["skill_changes"] == []
 
 
+def test_run_reflection_job_canonicalizes_escaped_json_receipt(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """Escaped JSON object text from a child turn is normalized before validation."""
+    home = tmp_path / "home"
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    monkeypatch.setenv("CODEX_SELF_EVOLUTION_HOME", str(home))
+    monkeypatch.setenv("CSEP_CODEX_SKILLS_DIR", str(tmp_path / "skills"))
+    job = create_job_from_payload(_payload(repo), home=home)
+
+    updated = run_reflection_job(
+        str(job["job_id"]),
+        home=home,
+        client=FakeReflectionClient(
+            invalid_receipt_text=(
+                "{\\n"
+                '  \\"schema_version\\": 1,\\n'
+                '  \\"job_id\\": \\"wrong-job\\",\\n'
+                '  \\"parent_session_id\\": \\"wrong-parent\\",\\n'
+                '  \\"child_thread_id\\": \\"wrong-child\\",\\n'
+                '  \\"status\\": \\"succeeded\\",\\n'
+                '  \\"memory_changes\\": [],\\n'
+                '  \\"skill_changes\\": [],\\n'
+                '  \\"skipped_candidates\\": [],\\n'
+                '  \\"validation_notes\\": [],\\n'
+                '  \\"errors\\": [],\\n'
+                '  \\"started_at\\": \\"$run_ts\\",\\n'
+                '  \\"finished_at\\": \\"$run_ts\\"\\n'
+                "}"
+            ),
+        ),
+    )
+    receipt = json.loads((home / "session_reflection" / "runs" / str(job["job_id"]) / "receipt.json").read_text())
+
+    assert updated["status"] == "skipped_empty"
+    assert updated["validation"]["status"] == "skipped_empty"
+    assert receipt["job_id"] == job["job_id"]
+    assert receipt["parent_session_id"] == "parent-1"
+    assert receipt["child_thread_id"] == "child-1"
+    assert receipt["started_at"].endswith("Z")
+    assert receipt["validation_notes"][0]["reason"] == "receipt_envelope_canonicalized"
+
+
 def test_run_reflection_job_resets_trigger_counters_after_success(
     monkeypatch: pytest.MonkeyPatch,
     tmp_path: Path,
@@ -870,6 +915,46 @@ def test_session_reflection_status_reports_failure_details(
         "status": "failed",
         "reason": "missing_receipt",
         "error": "receipt missing",
+        "category": "child_receipt_contract",
+        "issue_counts": {},
+    }
+
+
+def test_session_reflection_status_classifies_validation_failures(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """Status explains whether validation failed in the child receipt or artifacts."""
+    home = tmp_path / "home"
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    monkeypatch.setenv("CODEX_SELF_EVOLUTION_HOME", str(home))
+    job = create_job_from_payload(_payload(repo), home=home)
+    update_job_status(
+        str(job["job_id"]),
+        "failed",
+        home=home,
+        validation={
+            "status": "failed",
+            "receipt_status": "succeeded",
+            "boundary_violations": [{"reason": "memory_outside_root", "path": "/tmp/outside.md"}],
+            "hash_mismatches": [],
+            "invalid_skills": [],
+            "low_value_memory_writes": [],
+        },
+    )
+
+    status = session_reflection_status(home=home)
+
+    assert status["latest"]["validation"] == {
+        "status": "failed",
+        "category": "child_artifact_boundary",
+        "issue_counts": {
+            "boundary_violations": 1,
+            "hash_mismatches": 0,
+            "invalid_skills": 0,
+            "low_value_memory_writes": 0,
+        },
     }