@arbiterforge/ca-pi 0.14.10 → 0.14.12

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

@@ -319,8 +319,17 @@ def _preflight_plan_authoring(
     *,
     spec_artifact_id: str,
     spec_normative_sha256: str,
+    draft_for_pair: bool = False,
 ) -> Path:
-    """Verify one approved HTML spec and return its unwritten plan target."""
+    """Verify the exact spec. Only initial sprint-pair preparation admits a ready draft.
+
+    Draft preparation never approves the spec or plan and never permits execution.
+    The ordinary feature/sequential path still requires an approved spec.
+    """
+    if type(draft_for_pair) is not bool:
+        raise ArtifactError("INVALID_ROUTE", "draft_for_pair must be an explicit boolean")
+    if draft_for_pair and (not isinstance(selected, dict) or selected.get("workflow") != "sprint" or selected.get("lane") != "full"):
+        raise ArtifactError("INVALID_ROUTE", "draft preview is limited to full-lane initial sprint pairs")
     if not isinstance(selected, dict):
         raise ArtifactError("INVALID_ROUTE", "plan authoring requires a selected route")
     slug = selected.get("slug")
@@ -376,7 +385,7 @@ def _preflight_plan_authoring(
         )
     approved = client.call(
         "validate",
-        {"artifact_id": spec_artifact_id, "gate": "approved"},
+        {"artifact_id": spec_artifact_id, "gate": "ready" if draft_for_pair else "approved"},
         permit_invalid=True,
     )
     authority = approved.get("authority")
@@ -385,8 +394,9 @@ def _preflight_plan_authoring(
         or approved.get("artifact_id") != spec_artifact_id
         or approved.get("normative_sha256") != spec_normative_sha256
         or not isinstance(authority, dict)
-        or authority.get("state") != "approved"
-        or authority.get("authority_verified") is not True
+        or approved.get("model_sha256") != identity.get("model_sha256")
+        or authority.get("state") != ("draft" if draft_for_pair else "approved")
+        or authority.get("authority_verified") is not (not draft_for_pair)
     ):
         raise ArtifactError(
             "AUTHORITY_UNVERIFIED",

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

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# codeArbiter — cross-repository routing for exact artifact authority prompts.
+"""Register and resolve target repositories without granting prompt authority."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import stat
+import tempfile
+
+
+REGISTRY_PARENT = Path(tempfile.gettempdir())
+FORMAT = "codearbiter.artifact-prompt-route/0.1.0"
+
+
+class PromptRouteError(RuntimeError):
+    pass
+
+
+def _canonical(value):
+    return json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(",", ":")).encode()
+
+
+def _digest(value: bytes) -> str:
+    return hashlib.sha256(value).hexdigest()
+
+
+def _identity(root: Path) -> dict[str, str]:
+    root = root.resolve(strict=True)
+    info = root.lstat()
+    reparse = getattr(info, "st_file_attributes", 0) & 0x400
+    if stat.S_ISLNK(info.st_mode) or reparse or not stat.S_ISDIR(info.st_mode):
+        raise PromptRouteError("artifact prompt target is not a real directory")
+    return {
+        "path": str(root),
+        "filesystem_id": f"{int(getattr(info, 'st_dev', 0))}:{int(getattr(info, 'st_ino', 0))}",
+    }
+
+
+def _registry() -> Path:
+    namespace = f"uid-{os.getuid()}" if hasattr(os, "getuid") else "current-user"
+    root = REGISTRY_PARENT.resolve(strict=True) / f"codearbiter-prompt-routes-{namespace}"
+    root.mkdir(mode=0o700, exist_ok=True)
+    info = root.lstat()
+    reparse = getattr(info, "st_file_attributes", 0) & 0x400
+    if stat.S_ISLNK(info.st_mode) or reparse or not stat.S_ISDIR(info.st_mode):
+        raise PromptRouteError("artifact prompt registry is unsafe")
+    if hasattr(os, "getuid"):
+        if info.st_uid != os.getuid():
+            raise PromptRouteError("artifact prompt registry has another owner")
+        os.chmod(root, 0o700)
+    return root
+
+
+def _key(route: str, artifact_id: str, repository: dict[str, str]) -> str:
+    return _digest(_canonical({"route": route, "artifact_id": artifact_id, "repository": repository}))
+
+
+def register(root: str | Path, route: str, artifact_id: str, prompt: str,
+             *, binding_sha256: str | None = None) -> None:
+    if route not in {"approval", "prerequisite", "reconciliation"} or not isinstance(prompt, str) or not prompt:
+        raise PromptRouteError("artifact prompt route is invalid")
+    if binding_sha256 is not None and (
+        not isinstance(binding_sha256, str)
+        or len(binding_sha256) != 64
+        or any(ch not in "0123456789abcdef" for ch in binding_sha256)
+    ):
+        raise PromptRouteError("artifact prompt binding is invalid")
+    repository = _identity(Path(root))
+    value = {
+        "format": FORMAT,
+        "route": route,
+        "artifact_id": artifact_id,
+        "prompt_sha256": _digest(prompt.encode("utf-8")),
+        "repository": repository,
+    }
+    if binding_sha256 is not None:
+        value["binding_sha256"] = binding_sha256
+    value["integrity_sha256"] = _digest(_canonical(value))
+    registry = _registry()
+    key = _key(route, artifact_id, repository)
+    path = registry / f"{key}.json"
+    data = _canonical(value)
+    # Each caller owns an exclusively created pending marker before registering.
+    # A prior route at this key therefore belongs to an interrupted request.
+    fd, temporary = tempfile.mkstemp(prefix=f".{key}.", suffix=".tmp", dir=registry)
+    try:
+        try:
+            view = memoryview(data)
+            while view:
+                written = os.write(fd, view)
+                if written <= 0:
+                    raise OSError("short prompt-route write")
+                view = view[written:]
+            os.fsync(fd)
+        finally:
+            os.close(fd)
+        os.replace(temporary, path)
+    finally:
+        try:
+            os.unlink(temporary)
+        except FileNotFoundError:
+            pass
+
+
+def resolve(route: str, prompt: str) -> Path | None:
+    if route not in {"approval", "prerequisite", "reconciliation"} or not isinstance(prompt, str):
+        return None
+    prompt_hash = _digest(prompt.encode("utf-8"))
+    matches = []
+    for path in _registry().glob("*.json"):
+        try:
+            raw = path.read_bytes()
+            if len(raw) > 16384:
+                continue
+            value = json.loads(raw.decode("utf-8"))
+            unsigned = dict(value)
+            integrity = unsigned.pop("integrity_sha256", None)
+            repository = value.get("repository")
+            if (
+                value.get("format") != FORMAT
+                or value.get("route") != route
+                or value.get("prompt_sha256") != prompt_hash
+                or integrity != _digest(_canonical(unsigned))
+                or not isinstance(repository, dict)
+            ):
+                continue
+            root = Path(repository.get("path", ""))
+            if _identity(root) != repository:
+                continue
+            matches.append(root.resolve(strict=True))
+        except (OSError, UnicodeError, ValueError, PromptRouteError):
+            continue
+    unique = {str(path): path for path in matches}
+    if len(unique) > 1:
+        raise PromptRouteError("artifact authority prompt matches multiple repositories")
+    return next(iter(unique.values()), None)
+
+
+def unregister(root: str | Path, route: str, artifact_id: str) -> None:
+    repository = _identity(Path(root))
+    path = _registry() / f"{_key(route, artifact_id, repository)}.json"
+    try:
+        path.unlink()
+    except FileNotFoundError:
+        pass
+
+
+def binding(root: str | Path, route: str, artifact_id: str) -> str | None:
+    repository = _identity(Path(root))
+    path = _registry() / f"{_key(route, artifact_id, repository)}.json"
+    try:
+        raw = path.read_bytes()
+        if len(raw) > 16384:
+            raise OSError("oversized prompt route")
+        value = json.loads(raw.decode("utf-8"))
+        unsigned = dict(value)
+        integrity = unsigned.pop("integrity_sha256", None)
+    except (OSError, UnicodeError, ValueError) as exc:
+        raise PromptRouteError("artifact prompt route is unreadable") from exc
+    if (
+        value.get("format") != FORMAT
+        or value.get("route") != route
+        or value.get("artifact_id") != artifact_id
+        or value.get("repository") != repository
+        or integrity != _digest(_canonical(unsigned))
+    ):
+        raise PromptRouteError("artifact prompt route is malformed")
+    result = value.get("binding_sha256")
+    if not isinstance(result, str) or len(result) != 64 or any(
+        ch not in "0123456789abcdef" for ch in result
+    ):
+        raise PromptRouteError("artifact prompt route has no closed binding")
+    return result

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

@@ -11,7 +11,7 @@ import hostapi  # noqa: E402
 class PiHost(hostapi.Host):
     name = "pi"
     adapter_name = "@arbiterforge/ca-pi"
-    adapter_version = "0.14.10"
+    adapter_version = "0.14.12"
     update_target = "ca-pi"
     update_tag_prefix = "ca-pi-v"
     update_command = "pi update npm:@arbiterforge/ca-pi"

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

@@ -78,7 +78,11 @@ def _validate_file_type(path):
 
 def _validate_existing(path, raw):
     _validate_file_type(path)
-    if raw.startswith(b"\xef\xbb\xbf") or b"\x00" in raw or b"\r" in raw:
+    # Historical audit bytes are immutable. A stray CR can exist in an older
+    # row without making a new O_APPEND write unsafe, so preserve it verbatim
+    # and require only that newly written rows use LF. Rewriting the file to
+    # normalize old bytes would violate the append-only contract.
+    if raw.startswith(b"\xef\xbb\xbf") or b"\x00" in raw:
         raise OverrideAppendError("overrides.log is not canonical UTF-8 LF text")
     try:
         raw.decode("utf-8", errors="strict")

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

@@ -38,6 +38,8 @@ import time
 from typing import Any
 
 import _artifactlib
+import _artifactauthoritylib
+import _artifactpromptlib
 from _hooklib import acquire_lock, release_lock
 
 
@@ -393,7 +395,7 @@ def _validate_record(value: Any, prerequisite_id: str) -> bool:
     )
 
 
-def _validate_confirmed_state(value: dict[str, Any]) -> None:
+def _validate_confirmed_state(value: dict[str, Any], *, check_source: bool = True) -> None:
     event = value["event"]
     expected_subject = {
         "artifact_id": value["artifact_id"],
@@ -444,7 +446,7 @@ def _validate_confirmed_state(value: dict[str, Any]) -> None:
     expected_source = (
         SOURCE_DIR / f"{_digest(_canonical(event))}.json"
     ).as_posix()
-    if value["authority_source"] != expected_source:
+    if check_source and value["authority_source"] != expected_source:
         raise PrerequisiteError(
             "INVALID_PENDING_PREREQUISITE",
             "confirmed authority source does not match the event",
@@ -535,7 +537,7 @@ def _load_pending(root: Path, artifact_id: str) -> dict[str, Any] | None:
             "INVALID_PENDING_PREREQUISITE", "captured state is incomplete"
         )
     else:
-        _validate_confirmed_state(value)
+        _validate_confirmed_state(value, check_source=False)
         if value["mutation_request"] != _expected_mutation_request(value):
             raise PrerequisiteError(
                 "INVALID_PENDING_PREREQUISITE",
@@ -601,16 +603,22 @@ def arm_user_prerequisite(
             "PENDING_PREREQUISITE",
             "resolve or cancel this plan's existing prerequisite request first",
         ) from exc
+    reply = (
+        f"satisfy-prerequisite {artifact_id} {prerequisite_id} "
+        f"{confirmation_nonce}"
+    )
+    try:
+        _artifactpromptlib.register(root, "prerequisite", artifact_id, reply)
+    except _artifactpromptlib.PromptRouteError:
+        (root / relative).unlink()
+        raise
     return {
         "artifact_id": artifact_id,
         "prerequisite_id": prerequisite_id,
         "title": record["title"],
         "requirement": record["requirement"],
         "review_packet_sha256": packet_sha256,
-        "reply": (
-            f"satisfy-prerequisite {artifact_id} {prerequisite_id} "
-            f"{confirmation_nonce}"
-        ),
+        "reply": reply,
         "pending": relative.as_posix(),
     }
 
@@ -752,12 +760,17 @@ def consume_user_prerequisite(
                 session_id=session_id,
                 now=observed_at,
             )
-        source_ref, source_sha256 = _publish_event(root, pending)
         if pending["state"] == "CONFIRMED":
-            captured = client.call(
-                "capture",
-                {"source_ref": source_ref, "source_sha256": source_sha256},
-            )
+            observed_host, separator, observed_session = pending["event"]["origin"].partition(":UserPromptSubmit:")
+            if not separator:
+                raise PrerequisiteError("INVALID_PENDING_PREREQUISITE", "confirmed prompt origin is malformed")
+            try:
+                captured = _artifactauthoritylib.capture_user_prompt(
+                    root, client, pending["event"], host=observed_host,
+                    session_id=observed_session,
+                )
+            except _artifactauthoritylib.AuthorityError as exc:
+                raise PrerequisiteError("INVALID_AUTHORITY_SOURCE", str(exc)) from exc
             receipt = captured.get("receipt")
             if not isinstance(receipt, str) or RECEIPT_RE.fullmatch(receipt) is None:
                 raise PrerequisiteError("INVALID_RECEIPT", "capture returned no valid receipt")
@@ -774,18 +787,20 @@ def consume_user_prerequisite(
             }
             captured_state = dict(pending)
             captured_state.update(
-                state="CAPTURED", receipt=receipt, mutation_request=mutation_request
+                state="CAPTURED", receipt=receipt, mutation_request=mutation_request,
+                authority_source=captured["authority_source"],
             )
             _replace_state(root, _pending_relative(artifact_id), captured_state)
             pending = captured_state
         result = client.call("prerequisite", pending["mutation_request"])
         (root / _pending_relative(artifact_id)).unlink()
+        _artifactpromptlib.unregister(root, "prerequisite", artifact_id)
         return {
             "matched": True,
             "satisfied": True,
             "artifact_id": artifact_id,
             "prerequisite_id": prerequisite_id,
-            "authority_source": source_ref,
+            "authority_source": pending["authority_source"],
             "receipt": pending["receipt"],
             "revision": result.get("revision"),
             "replayed": bool((result.get("transaction") or {}).get("replayed")),
@@ -817,6 +832,7 @@ def cancel_user_prerequisite(
                 "a confirmed prerequisite decision must be recovered, not cancelled",
             )
         (root / _pending_relative(artifact_id)).unlink()
+        _artifactpromptlib.unregister(root, "prerequisite", artifact_id)
         return {
             "artifact_id": artifact_id,
             "prerequisite_id": prerequisite_id,
@@ -868,6 +884,7 @@ def supersede_user_prerequisite(
                     raise
             else:
                 (root / _pending_relative(artifact_id)).unlink()
+                _artifactpromptlib.unregister(root, "prerequisite", artifact_id)
                 return {
                     "artifact_id": artifact_id,
                     "prerequisite_id": prerequisite_id,
@@ -878,6 +895,7 @@ def supersede_user_prerequisite(
                     "replayed": bool((result.get("transaction") or {}).get("replayed")),
                 }
         (root / _pending_relative(artifact_id)).unlink()
+        _artifactpromptlib.unregister(root, "prerequisite", artifact_id)
         return {
             "artifact_id": artifact_id,
             "prerequisite_id": prerequisite_id,
@@ -904,20 +922,23 @@ def consume_from_hook(
             if attempted
             else ""
         )
-    if not (Path(root) / _pending_relative(match[0])).exists():
-        return (
-            "codeArbiter: prerequisite capture failed: no matching armed request"
-            if attempted
-            else ""
-        )
     try:
+        routed = _artifactpromptlib.resolve("prerequisite", prompt)
+        root = routed or Path(root)
+        if not (Path(root) / _pending_relative(match[0])).exists():
+            return (
+                "codeArbiter: prerequisite capture failed: no matching armed request"
+                if attempted
+                else ""
+            )
         client = _artifactlib.ArtifactClient(
             root, Path(plugin_root) / "helpers" / "artifacts"
         )
         result = consume_user_prerequisite(
             root, client, prompt, host=host, session_id=session_id
         )
-    except (PrerequisiteError, _artifactlib.ArtifactError, OSError) as exc:
+    except (PrerequisiteError, _artifactlib.ArtifactError,
+            _artifactpromptlib.PromptRouteError, OSError) as exc:
         return f"codeArbiter: prerequisite capture failed: {exc}"
     if not result.get("satisfied"):
         return "codeArbiter: prerequisite capture failed: confirmation did not match"
@@ -966,6 +987,7 @@ def main(argv: list[str] | None = None) -> int:
 if __name__ == "__main__":
     try:
         raise SystemExit(main())
-    except (PrerequisiteError, _artifactlib.ArtifactError) as exc:
+    except (PrerequisiteError, _artifactlib.ArtifactError,
+            _artifactpromptlib.PromptRouteError) as exc:
         sys.stderr.write(str(exc) + "\n")
         raise SystemExit(1)