@arbiterforge/ca-pi 0.14.17 → 0.15.1

package/README.md

@@ -10,7 +10,7 @@ project context. You decide. codeArbiter enforces.
 <img alt="Claude Code plugin" src="https://img.shields.io/badge/Claude_Code-plugin-d97757">
 <img alt="Codex plugin" src="https://img.shields.io/badge/OpenAI_Codex-plugin-10a37f">
 <img alt="Pi Feature Forge preview" src="https://img.shields.io/badge/ca--pi-Feature_Forge_preview-d97757">
-<img alt="version 2.21.17" src="https://img.shields.io/badge/version-2.21.17-2b7489">
+<img alt="version 2.22.1" src="https://img.shields.io/badge/version-2.22.1-2b7489">
 <img alt="core lanes" src="https://img.shields.io/badge/core_lanes-18-555">
 <img alt="skills" src="https://img.shields.io/badge/skills-23-555">
 <img alt="agents" src="https://img.shields.io/badge/agents-20-555">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arbiterforge/ca-pi",
-  "version": "0.14.17",
+  "version": "0.15.1",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",

package/plugins/ca-pi/CHANGELOG.md

@@ -4,6 +4,31 @@ All notable changes to `ca-pi` are documented in this file.
 
 ## [Unreleased]
 
+## [0.15.1] - 2026-09-26
+
+### Fixed
+
+- Ship the shared whole-plan verification preflight, exact named-result collectors,
+  and pinned native Windows npm runner contract.
+- Reject ineffective snapshot exclusions, prevent explicit roots from bypassing
+  exclusions, and retain actionable oversized-input diagnostics.
+
+## [0.15.0] - 2026-09-26
+
+### Added
+
+- Approve a structured artifact by typing a four-character code, for example
+  `approve K7MQ`, instead of pasting a long token. The hook expands it to the
+  exact armed reply, so the engine and recorded evidence are unchanged.
+- On Claude Code, approve by clicking an Approve option in the host's own
+  question dialog; the recorded origin names that seam.
+
+### Fixed
+
+- Replies with extra spacing, invisible characters, backticks, quotes or a
+  closing period are no longer ignored; a reply that still cannot match now
+  says why instead of failing silently.
+
 ## [0.14.17] - 2026-09-25
 
 ### Fixed

package/plugins/ca-pi/helpers/artifacts/release.json

@@ -6,32 +6,32 @@
   "binaries": {
     "darwin/amd64": {
       "file": "ca-artifact-darwin-amd64",
-      "sha256": "8e2a1f3026d5d9a8de36f3f748a7140ecf1ef8e768022aaa8745884e09551f9a",
+      "sha256": "3c8d8deb48d85ba1c9a6cfaf1286543cc8193fc8db307fe35446f29e53d3ca7a",
       "native_tested": true
     },
     "darwin/arm64": {
       "file": "ca-artifact-darwin-arm64",
-      "sha256": "cce4b1cd751ada483bffd2de53bd14cdfda50f5d7392b49ba3f020b58fc59da4",
+      "sha256": "af3a36a6926532c6e0b4da10397aae17a472e300f50d5c0dc7886aa722046d28",
       "native_tested": true
     },
     "linux/amd64": {
       "file": "ca-artifact-linux-amd64",
-      "sha256": "7637fe233e8731f4f15ff36b2e80714edd7e6fd96117b41f911d0c8f46639615",
+      "sha256": "83300e32dd6514b4716707091d900611f42454097b177443c9c47f464cad5065",
       "native_tested": true
     },
     "linux/arm64": {
       "file": "ca-artifact-linux-arm64",
-      "sha256": "daa4ed9f1f577c59afd0250701959718f501799c204df01a92f00876c088f619",
+      "sha256": "47f1e529140642c7574f29664bb9adacc2755458a1cd9a30c6fdc0f9df447f24",
       "native_tested": true
     },
     "windows/amd64": {
       "file": "ca-artifact-windows-amd64.exe",
-      "sha256": "16a3a26c5c606fe77703cbc9ae69414cbbe93f2c50dda9301eb9784e2e842206",
+      "sha256": "fa1a11489cc4521c945a59d2dce9f270ba9fcf6fcdc220011579326d5e97569a",
       "native_tested": true
     },
     "windows/arm64": {
       "file": "ca-artifact-windows-arm64.exe",
-      "sha256": "f64155cd951be94039ea85d4420b2d3bad75ebcb14e68aeb15be8ccf9ec1f690",
+      "sha256": "88e0e9c2cf7d5861ff1365d8aa4d9376f6fa1ff8cdf0eb708be78be88af45468",
       "native_tested": true
     }
   }

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

@@ -17,6 +17,7 @@ from typing import Any
 import _artifactlib
 import _artifactauthoritylib
 import _artifactpromptlib
+import _replylib
 
 
 PENDING = Path(".codearbiter/.markers/pending-user-approval.json")
@@ -70,7 +71,102 @@ def _ready(client: Any, identity: dict[str, Any]) -> None:
         or result.get("model_sha256") != identity["model_sha256"]
         or result.get("normative_sha256") != identity["normative_sha256"]
     ):
-        raise ApprovalError("NOT_READY", "only the exact current ready artifact can be armed")
+        details = "; ".join(
+            f"{item.get('code', 'NOT_READY')} {item.get('symbol', '')} {item.get('field', '')}: {item.get('message', '')}"
+            for item in result.get("diagnostics", []) if isinstance(item, dict)
+        )
+        raise ApprovalError("NOT_READY", "only the exact current ready artifact can be armed" + (": " + details if details else ""))
+
+
+def _preflight_plan_verification(client: Any, identity: dict[str, Any]) -> dict[str, Any]:
+    """Inspect the whole engine-owned plan before requesting approval.
+
+    This private admission check runs no declared command or test discovery.
+    Proposed tests may be absent. Existing input roots must already be readable;
+    a containing directory records future file creation in the input snapshot.
+    Runtime binding, host authorization and fresh evidence remain separate.
+    """
+    if identity.get("kind") != "plan":
+        raise _artifactlib.ArtifactError("WRONG_KIND", "verification preflight requires a plan")
+    keys = ("artifact_id", "revision", "model_sha256", "normative_sha256")
+    artifact_id = identity["artifact_id"]
+
+    def same_identity(value: dict[str, Any]) -> None:
+        if not isinstance(value, dict) or any(value.get(key) != identity.get(key) for key in keys):
+            raise _artifactlib.ArtifactError("STALE_PLAN_PREFLIGHT", "plan identity changed during verification preflight; reread the complete current plan")
+
+    same_identity(client.call("identity", {"artifact_id": artifact_id}))
+    root = _artifactlib._trusted_directory(client.root, "UNSAFE_ROOT")
+    diagnostics: list[str] = []
+    seen: set[str] = set()
+    command_count = 0
+    offset, total = 0, None
+    for _ in range(8193):
+        request = {"artifact_id": artifact_id, "offset": offset, "budget": 16384}
+        if offset:
+            request["model_sha256"] = identity["model_sha256"]
+        page = client.call("outline", request)
+        same_identity(page)
+        _artifactlib.ArtifactClient._check_page(page, offset, "records")
+        if (page.get("offset") != offset or type(page.get("total")) is not int
+                or page["total"] < offset + len(page["records"])
+                or total is not None and page["total"] != total):
+            raise _artifactlib.ArtifactError("INVALID_RESPONSE", "plan outline count or offset changed")
+        total = page["total"]
+        for row in page["records"]:
+            if (not isinstance(row, dict) or not isinstance(row.get("id"), str)
+                    or row["id"] in seen or type(row.get("retired")) is not bool):
+                raise _artifactlib.ArtifactError("INVALID_RESPONSE", "plan outline contains an invalid or duplicate record")
+            seen.add(row["id"])
+            if row.get("kind") != "tasks" or row["retired"]:
+                continue
+            exact = client.call("read", {"artifact_id": artifact_id, "symbol": row["id"], "mode": "exact", "budget": 16384})
+            same_identity(exact)
+            task = exact.get("record")
+            if (not isinstance(task, dict) or task.get("id") != row["id"]
+                    or not isinstance(task.get("verification"), list) or not task["verification"]):
+                raise _artifactlib.ArtifactError("INVALID_RESPONSE", "plan task lacks complete verification definitions")
+            for number, definition in enumerate(task["verification"], 1):
+                command_count += 1
+                try:
+                    if not isinstance(definition, dict):
+                        raise _artifactlib.ArtifactError("INVALID_RESPONSE", "verification definition is not an object")
+                    label = definition.get("cwd")
+                    cwd = None
+                    if label in {".", "current worktree", "candidate worktree"}:
+                        cwd = root
+                    elif isinstance(label, str):
+                        relative = Path(label)
+                        if relative.is_absolute() or ".." in relative.parts:
+                            raise _artifactlib.ArtifactError("UNSUPPORTED_WORKSPACE", "declared cwd must be a contained repository path or mapped worktree label")
+                        candidate = root / relative
+                        if candidate.exists():
+                            cwd = _artifactlib._trusted_directory(candidate, "UNSUPPORTED_WORKSPACE")
+                    _artifactauthoritylib.validate_command_definition(definition, cwd=cwd)
+                except (_artifactlib.ArtifactError, _artifactauthoritylib.AuthorityError) as exc:
+                    argv = definition.get("argv") if isinstance(definition, dict) else None
+                    diagnostics.append(f"{row['id']} verification[{number}] {json.dumps(argv, ensure_ascii=True)}: {exc}")
+        next_offset = page["next_offset"]
+        expected = offset + len(page["records"])
+        if next_offset is None:
+            if expected != total:
+                raise _artifactlib.ArtifactError("INVALID_RESPONSE", "plan outline ended before every record was inspected")
+            break
+        if next_offset != expected:
+            raise _artifactlib.ArtifactError("INVALID_RESPONSE", "plan outline skipped records")
+        offset = next_offset
+    else:
+        raise _artifactlib.ArtifactError("INVALID_RESPONSE", "plan outline did not terminate")
+    try:
+        snapshot = client.call("snapshot", {"artifact_id": artifact_id})
+    except _artifactlib.ArtifactError as exc:
+        diagnostics.append(f"verification_inputs: {exc}")
+        snapshot = None
+    same_identity(client.call("identity", {"artifact_id": artifact_id}))
+    if diagnostics:
+        raise _artifactlib.ArtifactError("PLAN_VERIFICATION_UNAVAILABLE", "; ".join(diagnostics))
+    return {"artifact_id": artifact_id, "model_sha256": identity["model_sha256"],
+            "command_count": command_count, "snapshot": snapshot}
 
 
 def _safe_directory(root: Path, relative: Path, *, create: bool) -> Path:
@@ -134,6 +230,8 @@ def arm_user_approval(
     root = Path(root).resolve(strict=True)
     identity = _identity(client, artifact_id)
     _ready(client, identity)
+    if identity["kind"] == "plan":
+        _preflight_plan_verification(client, identity)
     token = token or secrets.token_urlsafe(24)
     if not TOKEN_RE.fullmatch(token):
         raise ApprovalError("INVALID_TOKEN", "approval token has an invalid shape")
@@ -159,9 +257,21 @@ def arm_user_approval(
     except _artifactpromptlib.PromptRouteError:
         (root / PENDING).unlink()
         raise
+    reply = f"approve {artifact_id} {token}"
+    code = _replylib.offer_code(root, "approval", artifact_id, reply,
+                                names=[artifact_id], short_prefix=["approve"])
+    envelope = _replylib.ask_envelope(
+        root, "approval", artifact_id, code_fields=code,
+        question=(f"Approve {identity['kind']} {artifact_id} revision {identity['revision']} "
+                  f"as you reviewed it? (normative {identity['normative_sha256'][:12]})"),
+        header=f"Approve {code.get('code', '')}",
+        description=f"Records your approval of this exact revision. Same as typing {code.get('short_reply')}.",
+    )
     return {
         "artifact_id": artifact_id,
-        "reply": f"approve {artifact_id} {token}",
+        "reply": reply,
+        **code,
+        **({"ask_envelope": envelope} if envelope else {}),
         "model_sha256": identity["model_sha256"],
         "normative_sha256": identity["normative_sha256"],
     }
@@ -243,14 +353,17 @@ def consume_user_approval(
     *,
     host: str,
     session_id: str,
+    seam: str = "UserPromptSubmit",
 ) -> dict[str, Any]:
     root = Path(root).resolve(strict=True)
+    if seam not in {"UserPromptSubmit", "AskUserQuestion"}:
+        raise ApprovalError("INVALID_HOST_CONTEXT", "approval seam is unsupported")
     pending = _load_pending(root)
     if pending is None or not isinstance(prompt, str):
         return {"matched": False, "approved": False}
     if pending["format"] == "codearbiter.pending-user-approval/0.2.0":
         import _sprintapprovallib
-        return _sprintapprovallib.consume(root, client, pending, prompt, host=host, session_id=session_id)
+        return _sprintapprovallib.consume(root, client, pending, prompt, host=host, session_id=session_id, seam=seam)
     parts = prompt.split(" ")
     if len(parts) != 3 or parts[0] != "approve" or parts[1] != pending["artifact_id"]:
         return {"matched": False, "approved": False}
@@ -277,7 +390,7 @@ def consume_user_approval(
             "record_id": current["artifact_id"],
         },
         "actor": "interactive repository user",
-        "origin": f"{host}:UserPromptSubmit:{session_id}",
+        "origin": f"{host}:{seam}:{session_id}",
         "verdict": "approved",
         "payload": {},
         "source_text": prompt,
@@ -316,25 +429,37 @@ def consume_user_approval(
 
 
 def consume_from_hook(*, root: str | Path, plugin_root: str | Path, prompt: str,
-                      host: str, session_id: str) -> str:
+                      host: str, session_id: str, seam: str = "UserPromptSubmit") -> str:
+    raw = prompt
+    prepared = _replylib.prepare(raw, "approval")
+    prompt = prepared["text"]
+    attempted = prepared["attempted"]
+
+    def missed(reason: str) -> str:
+        _replylib.record_near_miss(root, raw, reason)
+        return prepared["notice"] or _replylib.miss_notice("approve K7MQ")
+
+    if prepared["notice"]:
+        return missed("code")
     try:
         routed = _artifactpromptlib.resolve("approval", prompt)
         root = routed or Path(root)
         if not (Path(root) / PENDING).exists():
-            return ""
+            return missed("no-pending") if attempted else ""
         client = _artifactlib.ArtifactClient(
             root, Path(plugin_root) / "helpers" / "artifacts"
         )
         result = consume_user_approval(
-            root, client, prompt, host=host, session_id=session_id
+            root, client, prompt, host=host, session_id=session_id, seam=seam
         )
     except (ApprovalError, _artifactlib.ArtifactError,
             _artifactpromptlib.PromptRouteError, OSError) as exc:
-        if isinstance(prompt, str) and prompt.startswith(("approve ", "approve-sprint ")):
+        if attempted:
+            _replylib.record_near_miss(root, raw, "capture-failed")
             return f"codeArbiter: approval capture failed: {exc}"
         return ""
     if not result.get("approved"):
-        return ""
+        return missed("mismatch") if attempted else ""
     return (
         "codeArbiter: workflow approval recorded for "
         f"{result['artifact_id']} (receipt {result['receipt']})."