@arbiterforge/ca-pi 0.10.13 → 0.14.7

package/plugins/ca-pi/hooks/_protectedstatelib.py

@@ -381,6 +381,16 @@ def marker_name_for(rel_path):
     (non-empty) rel_path can ever produce, since a real segment always
     contributes a non-empty stem.
 
+    Every segment is case-folded (`.lower()`) before encoding (#624), matching
+    `_canon`/`lookup_policy`'s own case-insensitive registry comparison: a
+    marker name computed for a differently-cased Write/Edit target must equal
+    the one minted under the registry's canonical casing, or a legitimate
+    authoring write is wrongly blocked despite a fresh, correctly-minted
+    marker. This widens what two paths can collide into one marker (a
+    same-name directory differing only by case now shares a marker with its
+    canonical sibling) - the same accepted "widens admission, never narrows
+    protection" tradeoff `lookup_policy`'s own case fold already makes.
+
     Residual (accepted): the escaping above closes hyphen/segment-boundary
     ambiguity but is not a fully bijective encoding against adversarially
     crafted underscore runs (e.g. a directory literally named "a_" holding
@@ -388,7 +398,7 @@ def marker_name_for(rel_path):
     small, curated, human-authored set (spec B1/B2), not attacker-chosen
     directory names, so this is judged out of proportion to close fully
     here."""
-    parts = [p for p in norm_path(rel_path).split("/") if p not in ("", ".", "..")]
+    parts = [p for p in norm_path(rel_path).lower().split("/") if p not in ("", ".", "..")]
     if not parts:
         return "-authoring"
     if parts[0] == ".codearbiter" and len(parts) > 1:

package/plugins/ca-pi/hooks/_readinjectlib.py

@@ -1084,3 +1084,123 @@ def compute_injection(root, session_id, rel, runner=None):
         return ""
     except Exception:  # noqa: BLE001
         return ""
+
+# Typed artifact pilot bridge. Keep legacy matching unchanged; never cache HTML
+# authority by mtime. Importing this module performs no subprocess or file I/O.
+_artifact_legacy_build_index = build_index
+_artifact_legacy_spec_pointers = spec_pointers
+
+
+def build_index(root):
+    result = _artifact_legacy_build_index(root)
+    if not isinstance(result, dict):
+        return result
+    result = dict(result)
+    try:
+        from _artifactlib import ArtifactClient, helper_installation, has_html
+        if not has_html(root):
+            return result
+        # Preserve full engine identities in the advisory snapshot. Pointer
+        # matching uses only spec/path/globs, while dedup below hashes the same
+        # entries including revision/model/normative identity. Do not reread the
+        # artifact after this validated index stream.
+        extra = []
+        client = ArtifactClient(root, helper_installation(__file__))
+        for entry in client.index("spec"):
+            authority = entry["authority"]
+            if authority["authority_verified"] and entry.get("governs"):
+                extra.append({
+                    "spec": entry["artifact_id"],
+                    "path": entry["path"],
+                    "globs": entry["governs"],
+                    "artifact_html": True,
+                    "revision": entry.get("revision"),
+                    "model_sha256": entry.get("model_sha256"),
+                    "normative_sha256": entry.get("normative_sha256"),
+                })
+    except Exception as error:
+        # Advisory read injection remains fail-open. This warning is NOT an
+        # approved-spec pointer and MUST NOT authorize a planning/execution gate.
+        code = getattr(error, "code", "CAPABILITY_MISSING")
+        code = str(code)[:80]
+        capability_codes = {
+            "CAPABILITY_MISSING", "INVALID_INSTALLATION", "PACKAGE_INTEGRITY",
+            "UNSUPPORTED_PLATFORM", "UNSUPPORTED_VERSION", "UNVERIFIED_PLATFORM",
+            "INVALID_RESPONSE", "RESPONSE_TOO_LARGE", "SUBPROCESS_FAILED", "TIMEOUT",
+        }
+        extra = [{
+            "artifact_diagnostic": code,
+            "artifact_diagnostic_kind": (
+                "capability" if code in capability_codes else "invalid-artifact"
+            ),
+            "artifact_html": True,
+        }]
+    result["spec"] = [item for item in result.get("spec", [])
+                      if not isinstance(item, dict) or not item.get("artifact_html")] + extra
+    return result
+
+
+def spec_pointers(rel, index):
+    if not isinstance(index, list):
+        return _artifact_legacy_spec_pointers(rel, index)
+    warnings = [item for item in index if isinstance(item, dict) and item.get("artifact_diagnostic")]
+    normal = [item for item in index if not isinstance(item, dict) or not item.get("artifact_diagnostic")]
+    result = _artifact_legacy_spec_pointers(rel, normal)
+    if warnings:
+        warning = warnings[0]
+        code = warning["artifact_diagnostic"]
+        if warning.get("artifact_diagnostic_kind") == "capability":
+            text = (
+                "HTML artifact capability unavailable (" + code + "). Repair or reinstall "
+                "the pinned artifact payload. Source inspection and unrelated legacy Markdown "
+                "may continue; HTML planning/execution must stop until resolved."
+            )
+        else:
+            text = (
+                "HTML specification is invalid or unreadable (" + code + "). Inspect the "
+                "engine diagnostic and repair-preview before any repair. Source inspection may "
+                "continue; HTML planning/execution must stop until resolved."
+            )
+        result.append({"tier": "artifact-diagnostic", "text": text})
+    return result
+
+_artifact_legacy_compute_injection = compute_injection
+
+
+def compute_injection(root, session_id, rel, runner=None):
+    # Bind the injected pointers and dedup epoch to ONE validated HTML snapshot.
+    # A second artifact read here permits B(epoch) -> A(content) and records A
+    # under B's marker, suppressing a later stable B read. HTML therefore builds
+    # once before dedup; the same entries drive both context and epoch. This is
+    # advisory identity only, never approval or execution authority.
+    if not isinstance(rel, str) or rel.replace("\\", "/").split("/", 1)[0] == ".codearbiter":
+        return _artifact_legacy_compute_injection(root, session_id, rel, runner)
+    try:
+        from _artifactlib import has_html
+        if not has_html(root):
+            return _artifact_legacy_compute_injection(root, session_id, rel, runner)
+        index = build_index(root)
+        if not isinstance(index, dict):
+            return ""
+        artifact_entries = [
+            item for item in index.get("spec", [])
+            if isinstance(item, dict) and item.get("artifact_html") is True
+        ]
+        epoch = hashlib.sha256(
+            json.dumps(
+                artifact_entries, sort_keys=True, separators=(",", ":")
+            ).encode()
+        ).hexdigest()
+        epoch_session = str(session_id) + "|html:" + epoch
+        if already_injected(root, epoch_session, rel):
+            return ""
+        pointers = governing_docs(rel, index, runner)
+        if not pointers:
+            return ""
+        context = assemble_context(pointers, budget=150)
+        if context:
+            record_injection(root, epoch_session, rel)
+            return context
+        return ""
+    except Exception:  # noqa: BLE001 - advisory injection always fails open
+        return ""