cortex-loop 0.1.0a1__tar.gz → 0.1.0a2__tar.gz

{cortex_loop-0.1.0a1/cortex_loop.egg-info → cortex_loop-0.1.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cortex-loop
-Version: 0.1.0a1
+Version: 0.1.0a2
 Summary: Runtime-agnostic enforcement layer for AI coding agents
 Author: Cortex contributors
 License-Expression: MIT
@@ -46,7 +46,8 @@ The stop path is the product. Cortex is not a planning framework, generic memory
 | --- | --- | --- | --- |
 | Claude Code | `cortex runtime install --profile claude` | Shipped | Strongest current runtime. The truthful boundary is live-proven; remaining caveats are minor. |
 | Gemini CLI | `cortex runtime install --profile gemini` | Shipped with watchlist | The truthful boundary is live-proven. One operational watchlist remains: blocked malformed stops can leave Gemini CLI resident until operator termination. |
-| OpenAI Codex App Server | `cortex runtime install --profile openai` | Experimental | Several critical paths are proven on the latest stable surface, but positive strict close is still not dependable enough for broader support. |
+| OpenAI Codex App Server (native) | `cortex runtime install --profile openai` | Experimental | Honest native App Server surface: one turn, then stop audit. Several critical paths are proven, but positive strict close is still not dependable enough for broader support. |
+| OpenAI Codex App Server (assisted) | `cortex runtime install --profile openai-assisted` | Experimental | Explicit bounded assisted mode with a current committed shared-harness pair: Cortex provides session-start context with a short kernel-owned completion preview, one short evidence-expectation line, and one kernel-derived corrective turn. The lane remains supplemental-only, not native-substitutive proof. |
 
 Status labels in this table:
 - `Shipped`: live-proven on the shared harness; remaining caveats are non-critical.
@@ -55,23 +56,36 @@ Status labels in this table:
 
 Detailed runtime release evidence lives in [docs/ADAPTER_VALIDATION.md](docs/ADAPTER_VALIDATION.md) plus committed provenance under [tests/fixtures/adapter_validation/claude/PROVENANCE.json](tests/fixtures/adapter_validation/claude/PROVENANCE.json), [tests/fixtures/adapter_validation/gemini/PROVENANCE.json](tests/fixtures/adapter_validation/gemini/PROVENANCE.json), and [tests/fixtures/adapter_validation/openai/PROVENANCE.json](tests/fixtures/adapter_validation/openai/PROVENANCE.json).
 
+Current product-proof truth: Cortex is strong on truthful completion boundaries,
+but the repo still does not earn a net-positive product claim over the raw
+model. Phase 9 is landed at a truthful-withheld endpoint rather than an earned
+product-proof win.
+
+This repo state is also the final archival v1 reference point for the
+enforcement-layer line. The archival package target is `cortex-loop 0.1.0a2`.
+
 ## Quickstart
 
-As of 2026-03-07, `cortex-loop` is not yet published on PyPI. Until live
-package publication is proven, the truthful first-run path is from a repo
-checkout:
+Default public install:
 
 ```bash
-python3 -m venv .venv
-. .venv/bin/activate
-python -m pip install . pytest
+pipx install cortex-loop
 cortex init
 cortex runtime install --profile claude
 ```
 
-Before `cortex check`, choose the baseline that matches the repository:
+Supported advanced alternative:
+
+```bash
+uv tool install cortex-loop
+```
+
+Before `cortex check`, choose the baseline that matches the repository or the
+machine you are using:
 
-- trusted local repo: switch `cortex.toml` to the trusted-host baseline in
+- trusted local repo without Docker: add `pytest` to the promoted tool surface
+  (`pipx inject cortex-loop pytest` or `uv tool install --with pytest
+  cortex-loop`) and switch `cortex.toml` to the trusted-host baseline in
   [docs/SECURE_DEFAULTS.md](docs/SECURE_DEFAULTS.md)
 - untrusted or container baseline: keep the defaults and ensure Docker is on
   `PATH`
@@ -82,12 +96,21 @@ Then run:
 cortex check
 ```
 
-The staged public install posture, update and uninstall commands, and the PyPI
-publication gate live in [docs/INSTALL.md](docs/INSTALL.md).
+Install, update, uninstall, and live proof details live in
+[docs/INSTALL.md](docs/INSTALL.md).
+Guided evaluator onboarding lives in
+[docs/ALPHA_TESTER_ONBOARDING.md](docs/ALPHA_TESTER_ONBOARDING.md).
+Trust boundary and pack review posture live in
+[docs/TRUST_BOUNDARY.md](docs/TRUST_BOUNDARY.md) and
+[docs/PACK_POLICY.md](docs/PACK_POLICY.md).
 
 For a first evaluation, keep `claude`. Use `gemini` when you want the shipped
 watchlist surface. Use `openai` only when you are explicitly evaluating the
-experimental surface.
+experimental native surface. Use `openai-assisted` when you want the current
+bounded assisted OpenAI lane: session-start context with a short kernel-owned
+completion preview, one short evidence-expectation line, one kernel-derived
+corrective turn aimed at the unresolved completion gap, and a current
+shared-harness pair that still remains supplemental-only.
 
 ## What Cortex Enforces
 

{cortex_loop-0.1.0a1 → cortex_loop-0.1.0a2}/README.md

@@ -14,7 +14,8 @@ The stop path is the product. Cortex is not a planning framework, generic memory
 | --- | --- | --- | --- |
 | Claude Code | `cortex runtime install --profile claude` | Shipped | Strongest current runtime. The truthful boundary is live-proven; remaining caveats are minor. |
 | Gemini CLI | `cortex runtime install --profile gemini` | Shipped with watchlist | The truthful boundary is live-proven. One operational watchlist remains: blocked malformed stops can leave Gemini CLI resident until operator termination. |
-| OpenAI Codex App Server | `cortex runtime install --profile openai` | Experimental | Several critical paths are proven on the latest stable surface, but positive strict close is still not dependable enough for broader support. |
+| OpenAI Codex App Server (native) | `cortex runtime install --profile openai` | Experimental | Honest native App Server surface: one turn, then stop audit. Several critical paths are proven, but positive strict close is still not dependable enough for broader support. |
+| OpenAI Codex App Server (assisted) | `cortex runtime install --profile openai-assisted` | Experimental | Explicit bounded assisted mode with a current committed shared-harness pair: Cortex provides session-start context with a short kernel-owned completion preview, one short evidence-expectation line, and one kernel-derived corrective turn. The lane remains supplemental-only, not native-substitutive proof. |
 
 Status labels in this table:
 - `Shipped`: live-proven on the shared harness; remaining caveats are non-critical.
@@ -23,23 +24,36 @@ Status labels in this table:
 
 Detailed runtime release evidence lives in [docs/ADAPTER_VALIDATION.md](docs/ADAPTER_VALIDATION.md) plus committed provenance under [tests/fixtures/adapter_validation/claude/PROVENANCE.json](tests/fixtures/adapter_validation/claude/PROVENANCE.json), [tests/fixtures/adapter_validation/gemini/PROVENANCE.json](tests/fixtures/adapter_validation/gemini/PROVENANCE.json), and [tests/fixtures/adapter_validation/openai/PROVENANCE.json](tests/fixtures/adapter_validation/openai/PROVENANCE.json).
 
+Current product-proof truth: Cortex is strong on truthful completion boundaries,
+but the repo still does not earn a net-positive product claim over the raw
+model. Phase 9 is landed at a truthful-withheld endpoint rather than an earned
+product-proof win.
+
+This repo state is also the final archival v1 reference point for the
+enforcement-layer line. The archival package target is `cortex-loop 0.1.0a2`.
+
 ## Quickstart
 
-As of 2026-03-07, `cortex-loop` is not yet published on PyPI. Until live
-package publication is proven, the truthful first-run path is from a repo
-checkout:
+Default public install:
 
 ```bash
-python3 -m venv .venv
-. .venv/bin/activate
-python -m pip install . pytest
+pipx install cortex-loop
 cortex init
 cortex runtime install --profile claude
 ```
 
-Before `cortex check`, choose the baseline that matches the repository:
+Supported advanced alternative:
+
+```bash
+uv tool install cortex-loop
+```
+
+Before `cortex check`, choose the baseline that matches the repository or the
+machine you are using:
 
-- trusted local repo: switch `cortex.toml` to the trusted-host baseline in
+- trusted local repo without Docker: add `pytest` to the promoted tool surface
+  (`pipx inject cortex-loop pytest` or `uv tool install --with pytest
+  cortex-loop`) and switch `cortex.toml` to the trusted-host baseline in
   [docs/SECURE_DEFAULTS.md](docs/SECURE_DEFAULTS.md)
 - untrusted or container baseline: keep the defaults and ensure Docker is on
   `PATH`
@@ -50,12 +64,21 @@ Then run:
 cortex check
 ```
 
-The staged public install posture, update and uninstall commands, and the PyPI
-publication gate live in [docs/INSTALL.md](docs/INSTALL.md).
+Install, update, uninstall, and live proof details live in
+[docs/INSTALL.md](docs/INSTALL.md).
+Guided evaluator onboarding lives in
+[docs/ALPHA_TESTER_ONBOARDING.md](docs/ALPHA_TESTER_ONBOARDING.md).
+Trust boundary and pack review posture live in
+[docs/TRUST_BOUNDARY.md](docs/TRUST_BOUNDARY.md) and
+[docs/PACK_POLICY.md](docs/PACK_POLICY.md).
 
 For a first evaluation, keep `claude`. Use `gemini` when you want the shipped
 watchlist surface. Use `openai` only when you are explicitly evaluating the
-experimental surface.
+experimental native surface. Use `openai-assisted` when you want the current
+bounded assisted OpenAI lane: session-start context with a short kernel-owned
+completion preview, one short evidence-expectation line, one kernel-derived
+corrective turn aimed at the unresolved completion gap, and a current
+shared-harness pair that still remains supplemental-only.
 
 ## What Cortex Enforces
 

{cortex_loop-0.1.0a1 → cortex_loop-0.1.0a2}/cortex/__init__.py

@@ -4,4 +4,4 @@ from .core import CortexKernel
 from .hooks import marker
 
 __all__ = ["CortexKernel", "marker"]
-__version__ = "0.1.0a1"
+__version__ = "0.1.0a2"

{cortex_loop-0.1.0a1 → cortex_loop-0.1.0a2}/cortex/adapters.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import importlib
-import json
 import logging
 import re
 from collections.abc import Mapping
@@ -32,6 +31,8 @@ CANONICAL_EVENT_ALIASES = {
     "pretooluse": "pre_tool_use",
     "post_tool_use": "post_tool_use",
     "posttooluse": "post_tool_use",
+    "post_tool_use_failure": "post_tool_use",
+    "posttoolusefailure": "post_tool_use",
     "stop": "stop",
 }
 
@@ -51,7 +52,7 @@ class ClaudeAdapter:
     def normalize(self, event_name: str, payload: Mapping[str, Any] | None = None) -> NormalizedEvent:
         name = _normalize_event_name(event_name, self.EVENT_ALIASES)
         data = dict(payload) if isinstance(payload, Mapping) else {}
-        data = _normalize_claude_payload(data)
+        data = _normalize_claude_payload(data, normalized_event_name=name)
         message = data.get("last_assistant_message")
         if isinstance(message, str):
             rewritten = _rewrite_legacy_trailer_markers(message)
@@ -94,6 +95,7 @@ class GeminiAdapter:
         _normalize_session_id(data)
         if name in {"pre_tool_use", "post_tool_use"}:
             _normalize_tool_name(data, candidate_keys=("tool_name",))
+            _normalize_gemini_file_targets(data)
         if name == "post_tool_use":
             _normalize_gemini_status(data)
         if name == "stop":
@@ -107,8 +109,13 @@ class GeminiAdapter:
                         type(prompt_response).__name__,
                     )
                 prompt_response = ""
-            stop_fields, passthrough = _normalize_gemini_stop_fields(prompt_response)
-            data["stop_fields"] = stop_fields
+            stop_fields, passthrough, parse_error = _normalize_gemini_stop_fields(prompt_response)
+            if isinstance(stop_fields, dict):
+                data["stop_fields"] = stop_fields
+            else:
+                data.pop("stop_fields", None)
+            if parse_error:
+                data["stop_fields_parse_error"] = parse_error
             data["last_assistant_message"] = passthrough
         return NormalizedEvent(name=name, payload=data)
 
@@ -193,14 +200,46 @@ def _normalize_event_name(event_name: str, aliases: dict[str, str]) -> str:
     return aliases.get(token) or aliases.get(token.replace("_", "")) or token
 
 
-def _normalize_claude_payload(payload: dict[str, Any]) -> dict[str, Any]:
+def _normalize_claude_payload(payload: dict[str, Any], *, normalized_event_name: str) -> dict[str, Any]:
     _normalize_tool_name(payload, candidate_keys=("tool_name", "tool", "toolName", "action"))
     _normalize_session_id(payload)
+    _normalize_claude_file_targets(payload)
+    if normalized_event_name == "session_start":
+        payload.setdefault("runtime_mode", "native_preview")
+        payload.setdefault("stop_trailer_marker", "STOP_FIELDS_JSON")
+    if normalized_event_name == "post_tool_use":
+        _normalize_claude_post_tool_status(payload)
     if "stop_fields" not in payload and "cortex_stop" in payload:
         payload["stop_fields"] = payload.get("cortex_stop")
     return payload
 
 
+def _normalize_claude_post_tool_status(payload: dict[str, Any]) -> None:
+    raw_hook = str(payload.get("hook_event_name") or "").strip()
+    if raw_hook == "PostToolUseFailure":
+        payload.setdefault("status", "error")
+    tool_response = payload.get("tool_response")
+    if isinstance(tool_response, Mapping):
+        response_error = tool_response.get("error")
+        if payload.get("status") is None and response_error:
+            payload["status"] = "error"
+        if payload.get("error") is None and isinstance(response_error, str) and response_error.strip():
+            payload["error"] = response_error.strip()
+
+
+def _normalize_claude_file_targets(payload: dict[str, Any]) -> None:
+    tool_input = payload.get("tool_input")
+    if not isinstance(tool_input, Mapping):
+        return
+    file_path = str(tool_input.get("file_path") or tool_input.get("path") or "").strip()
+    if not file_path:
+        return
+    payload.setdefault("target_files", [file_path])
+    tool_name = str(payload.get("tool_name") or "").strip().lower()
+    if tool_name in {"edit", "multiedit", "write", "notebookedit"}:
+        payload.setdefault("planned_files", [file_path])
+
+
 def _normalize_claude_stop_fields(message: str) -> tuple[dict[str, Any] | None, str]:
     parsed, _, _ = parse_stop_fields_json(message)
     passthrough = _strip_gemini_stop_markers(message)
@@ -255,7 +294,20 @@ def _normalize_gemini_status(payload: dict[str, Any]) -> None:
     payload["status"] = "ok"
 
 
-def _normalize_gemini_stop_fields(prompt_response: str) -> tuple[dict[str, Any], str]:
+def _normalize_gemini_file_targets(payload: dict[str, Any]) -> None:
+    tool_input = payload.get("tool_input")
+    if not isinstance(tool_input, Mapping):
+        return
+    file_path = str(tool_input.get("file_path") or tool_input.get("path") or "").strip()
+    if not file_path:
+        return
+    payload.setdefault("target_files", [file_path])
+    tool_name = str(payload.get("tool_name") or "").strip().lower()
+    if tool_name in {"replace", "write_file", "edit", "write"}:
+        payload.setdefault("planned_files", [file_path])
+
+
+def _normalize_gemini_stop_fields(prompt_response: str) -> tuple[dict[str, Any] | None, str, str]:
     parsed, marker_found, error = parse_stop_fields_json(prompt_response)
     passthrough = _strip_gemini_stop_markers(prompt_response)
 
@@ -263,16 +315,9 @@ def _normalize_gemini_stop_fields(prompt_response: str) -> tuple[dict[str, Any],
         stop_fields = {str(k): v for k, v in parsed.items()}
         if passthrough and not stop_fields.get("summary"):
             stop_fields["summary"] = passthrough
-        return stop_fields, passthrough
+        return stop_fields, passthrough, ""
 
-    stop_fields = _recover_partial_stop_fields(prompt_response)
-    if marker_found and error:
-        stop_fields["marker_parse_error"] = error
-    if passthrough:
-        stop_fields.setdefault("summary", passthrough)
-    elif prompt_response.strip():
-        stop_fields.setdefault("summary", prompt_response.strip())
-    return stop_fields, passthrough
+    return None, passthrough or prompt_response.strip(), str(error or "") if marker_found else ""
 
 
 def _strip_gemini_stop_markers(text: str) -> str:
@@ -289,48 +334,6 @@ def _strip_gemini_stop_markers(text: str) -> str:
         cleaned = cleaned[:marker_idx]
     return cleaned.strip()
 
-
-def _recover_partial_stop_fields(text: str) -> dict[str, Any]:
-    recovered: dict[str, Any] = {}
-
-    coverage: dict[str, bool] = {}
-    for key in ("null_inputs", "boundary_values", "error_handling", "graveyard_regression"):
-        match = re.search(rf'"{key}"\s*:\s*(true|false)', text, flags=re.IGNORECASE)
-        if match:
-            coverage[key] = match.group(1).lower() == "true"
-    if coverage:
-        recovered["challenge_coverage"] = coverage
-
-    truth_claims: dict[str, list[str]] = {}
-    for key in ("modified_files", "tests_ran"):
-        values = _recover_string_list(text, key)
-        if values:
-            truth_claims[key] = values
-    if truth_claims:
-        recovered["truth_claims"] = truth_claims
-
-    return recovered
-
-
-def _recover_string_list(text: str, key: str) -> list[str]:
-    match = re.search(rf'"{key}"\s*:\s*\[(.*?)\]', text, flags=re.DOTALL | re.IGNORECASE)
-    if not match:
-        return []
-    values: list[str] = []
-    seen: set[str] = set()
-    for token in re.findall(r'"((?:\\.|[^"\\])*)"', match.group(1)):
-        try:
-            value = str(json.loads(f'"{token}"'))
-        except json.JSONDecodeError:
-            value = token
-        cleaned = value.strip()
-        if not cleaned or cleaned in seen:
-            continue
-        seen.add(cleaned)
-        values.append(cleaned)
-    return values
-
-
 def _rewrite_legacy_trailer_markers(message: str) -> str:
     return (
         message.replace("CORTEX_STOP_JSON:", "STOP_FIELDS_JSON:")

{cortex_loop-0.1.0a1 → cortex_loop-0.1.0a2}/cortex/challenges.py

@@ -33,6 +33,7 @@ class ChallengeReport:
     diagnostics: list[dict[str, Any]]
     config_warnings: list[str]
     ok: bool
+    gap_entries: list[str] = field(default_factory=list)
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -45,6 +46,7 @@ class ChallengeReport:
             "diagnostics": self.diagnostics,
             "config_warnings": self.config_warnings,
             "ok": self.ok,
+            "gap_entries": self.gap_entries,
         }
 
 
@@ -67,6 +69,7 @@ class ChallengeEnforcer:
         missing: list[str] = []
         unverified: list[str] = []
         uncheckable: list[str] = []
+        gap_entries: list[str] = []
         diagnostics: list[dict[str, Any]] = []
         config_warnings: list[str] = []
         resolved_root = root.resolve() if root is not None else None
@@ -82,6 +85,7 @@ class ChallengeEnforcer:
         for category in self.config.active_categories:
             raw = coverage_payload.get(category)
             covered, evidence = self._coerce_coverage(raw)
+            gap_kind = "missing" if raw is None else "uncovered"
             if require_verifiable_coverage and covered:
                 verification = self._verify_covered_category(
                     evidence=evidence,
@@ -95,13 +99,16 @@ class ChallengeEnforcer:
                     reason = str(verification.get("reason") or "missing verifiable evidence")
                     if verification_status == "uncheckable":
                         uncheckable.append(category)
+                        gap_kind = "uncheckable"
                     else:
                         unverified.append(category)
+                        gap_kind = "unverified"
                     config_warnings.append(
                         f"Challenge coverage '{category}' marked covered but evidence is {verification_status}: {reason}"
                     )
             if not covered:
                 missing.append(category)
+                gap_entries.append(f"{category}:{gap_kind}")
                 diagnostics.append(
                     self._coverage_diagnostic(
                         category=category,
@@ -125,16 +132,31 @@ class ChallengeEnforcer:
             diagnostics=diagnostics,
             config_warnings=config_warnings,
             ok=ok,
+            gap_entries=sorted(set(gap_entries)),
         )
 
     def missing_coverage_diagnostics(self) -> list[dict[str, Any]]:
         return [
-            {"evidence_found": [], "evidence_expected": [f"challenge_coverage for: {', '.join(self.config.active_categories)}"], "gap_description": "No challenge_coverage was provided for the stop attempt.", "gap_characterization": "comprehension_gap", "distance_signal": "far"}
+            {
+                "evidence_found": [],
+                "evidence_expected": [f"challenge_coverage for: {', '.join(self.config.active_categories)}"],
+                "gap_description": "No challenge_coverage was provided for the stop attempt.",
+                "gap_characterization": "comprehension_gap",
+                "distance_signal": "far",
+                "gap_entries": ["__all__:missing"],
+            }
         ]
 
     def invalid_coverage_diagnostics(self, raw: Any) -> list[dict[str, Any]]:
         return [
-            {"evidence_found": [f"challenge_coverage={type(raw).__name__}"], "evidence_expected": ["challenge_coverage object keyed by active challenge categories"], "gap_description": "Challenge coverage used an invalid payload shape.", "gap_characterization": "comprehension_gap", "distance_signal": "far"}
+            {
+                "evidence_found": [f"challenge_coverage={type(raw).__name__}"],
+                "evidence_expected": ["challenge_coverage object keyed by active challenge categories"],
+                "gap_description": "Challenge coverage used an invalid payload shape.",
+                "gap_characterization": "comprehension_gap",
+                "distance_signal": "far",
+                "gap_entries": ["__all__:invalid_shape"],
+            }
         ]
 
     @staticmethod
@@ -200,11 +222,33 @@ class ChallengeEnforcer:
     ) -> dict[str, Any]:
         verification = evidence.get("verification") if isinstance(evidence, Mapping) else None
         if raw is None:
-            return {"evidence_found": [], "evidence_expected": [f"challenge_coverage.{category}=true"], "gap_description": f"Challenge category '{category}' was not addressed in stop coverage.", "gap_characterization": "comprehension_gap", "distance_signal": "far"}
+            return {
+                "evidence_found": [],
+                "evidence_expected": [f"challenge_coverage.{category}=true"],
+                "gap_description": f"Challenge category '{category}' was not addressed in stop coverage.",
+                "gap_characterization": "comprehension_gap",
+                "distance_signal": "far",
+                "gap_entries": [f"{category}:missing"],
+            }
 
         evidence_refs = _as_string_list(evidence.get("evidence")) if isinstance(evidence, Mapping) else []
         if require_verifiable_coverage and isinstance(verification, Mapping):
             status = str(verification.get("status") or "unverified")
-            return {"evidence_found": evidence_refs or [f"verification_status={status}"], "evidence_expected": [f"verifiable evidence for challenge '{category}'"], "gap_description": f"Challenge category '{category}' was claimed but not verifiably supported.", "gap_characterization": "execution_gap", "distance_signal": "moderate" if evidence_refs else "far"}
+            gap_kind = "uncheckable" if status == "uncheckable" else "unverified"
+            return {
+                "evidence_found": evidence_refs or [f"verification_status={status}"],
+                "evidence_expected": [f"verifiable evidence for challenge '{category}'"],
+                "gap_description": f"Challenge category '{category}' was claimed but not verifiably supported.",
+                "gap_characterization": "execution_gap",
+                "distance_signal": "moderate" if evidence_refs else "far",
+                "gap_entries": [f"{category}:{gap_kind}"],
+            }
 
-        return {"evidence_found": ["covered=false"], "evidence_expected": [f"challenge_coverage.{category}=true"], "gap_description": f"Challenge category '{category}' remains uncovered.", "gap_characterization": "comprehension_gap", "distance_signal": "moderate"}
+        return {
+            "evidence_found": ["covered=false"],
+            "evidence_expected": [f"challenge_coverage.{category}=true"],
+            "gap_description": f"Challenge category '{category}' remains uncovered.",
+            "gap_characterization": "comprehension_gap",
+            "distance_signal": "moderate",
+            "gap_entries": [f"{category}:uncovered"],
+        }