@arbiterforge/ca-pi 0.14.10 → 0.14.16

package/plugins/ca-pi/SPRINT.md

@@ -73,6 +73,33 @@ explicit "decide it this way" steers here. STOP for explicit user approval of th
 plan before autonomy begins. A blocking `[CONFIRM-NN]` is resolved here, with the user — never carried
 into autonomous execution unresolved.
 
+### Initial HTML approval sequence
+
+Prepare one review packet containing the ready spec, ready draft plan, adversarial findings and
+explicit delegation terms. The installed private pair adapter in
+`<plugin-root>/includes/artifacts.md` owns the combined one-reply transaction:
+
+1. Finish the spec as a ready draft. Let `writing-plans` use `_preflight_plan_authoring` with
+   `draft_for_pair: true` only for this full-lane initial sprint. Populate the same-slug plan as
+   `draft_preview`, validate both, and review their complete criteria, paths, tests and checkpoints.
+   Neither draft has execution authority. Do not separately approve or `plan-bind` this pair.
+2. Arm both exact identities with `arm-sprint`. Include `--delegate-methods` only when the presented
+   terms explicitly ask the user to delegate existing task-method revisions. Present the exact returned reply;
+   it names both artifacts and `delegate-methods` or `approve-only`, not an ambiguous generic yes.
+3. The existing qualified host observes that single reply. `sprint-approve` validates both frozen
+   definitions and commits approval plus plan binding in one recoverable native transaction.
+   Verify both current approved identities before execution. No execution before both approvals.
+
+One reply approves the reviewed pair, not future unbounded work. `delegate-methods` does not grant
+initial self-approval, product decisions, prerequisite satisfaction, new files, verification changes,
+commit/push, provider/spending/disclosure/publication authority, or any security bypass. Keep
+no per-feature interviews and no attended execution pauses. A declined, changed or unsupported pair
+retains drafts; capability absence is not permission to invent a legacy shadow or receipt.
+If an observed reply was interrupted, `resume-sprint` replays its stored transaction without asking
+for the same reply again. An armed request with no observed reply cannot be resumed as approval.
+The existing sequential single-artifact path remains available for `/feature` and older workflows;
+Markdown retains its original approval contract.
+
 **Recorded-intent read — BEFORE spec approval, fail-soft (ADR-0025):** consult
 `decisions/decision-log.md`, the accepted-ADR index, the `plans/` artifacts' section headings, and
 `open-questions.md`'s deferred sections — index-first, bodies only when the index names them
@@ -128,6 +155,26 @@ ambiguity, a trade-off, a non-obvious option — DECIDE rather than stop:
   before `· confidence:`. The `low`-confidence
   entries are exactly what the user reviews in the morning; nothing is hidden behind autonomy.
 
+### Typed SMARTS method authority
+
+After the pair's explicit `delegate-methods` approval, use the private `smarts-apply` producer for a
+material change to an existing task's method steps. First perform SMARTS Step 0 and the existing
+project/ADR/scope checks. Submit the actual options, six-lens comparison, selected option, strength
+and rationale with the exact plan revision/model hash and the retained initial `grant_receipt`.
+Use the private request shape and adapter in `<plugin-root>/includes/artifacts.md`; a pasted matrix
+or an append-only log is not itself authority. A single evidenced option is allowed; an in-scope tie
+uses the existing priorities rather than another user interview. Do not manufacture alternatives.
+
+The producer retains all protected plan fields and requires the original user-approved scope. It can
+change only existing task `steps`; paths, tests, criteria, dependencies, prerequisites, rollback and
+checkpoint membership cannot expand. It quiesces affected writers by refusing `IN_PROGRESS` and
+invalidates affected checkpoint/dependency proof before another attempt, without clearing `BLOCKED`
+members or their recorded reasons. A blocked method revision
+therefore resumes through fresh `eligible`, context tickets, verification and review, never auto-pass.
+The original log still records material reasoning and source citations. No result implies accepted
+work or independently proves the truth of model judgment. Changes outside the granted boundary use
+their actual authority owner; this producer does not satisfy prerequisites or waive security stops.
+
 ### Hard gates — true stops, even mid-sprint
 
 NEVER auto-decided. Halt and surface to the user:

package/plugins/ca-pi/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,40 @@
+# Third-party notices
+
+## Go runtime and standard library
+
+The packaged `ca-artifact` executable is built with Go and includes Go runtime
+and standard-library code. The following notice is from the Go 1.27.1 toolchain
+used by the native build. Upstream: https://go.dev/LICENSE.
+
+This runtime notice does not determine the provenance of the separately authored
+workflow skills. Their historical provenance review remains a separate task.
+
+```text
+Copyright 2009 The Go Authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google LLC nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+```

package/plugins/ca-pi/generated/command-catalog.json

@@ -125,7 +125,7 @@
     },
     "commit": {
       "name": "commit",
-      "description": "Run the full commit gate — the only sanctioned path to a git commit.",
+      "description": "Create a verified local Git commit when committing changes is requested. Not for explaining commit history, drafting a message only, or postponing a commit. Applies every commit gate and never implies a push or PR.",
       "skillPath": "skills/ca-commit/SKILL.md",
       "visibility": "core",
       "workflow": "ship",
@@ -227,7 +227,7 @@
     },
     "new-skill": {
       "name": "new-skill",
-      "description": "Author a new codeArbiter skill: prove the gap is real, get the spec approved, then write it.",
+      "description": "Assess a request for a new reusable codeArbiter skill, prove the uncovered gap, agree scope, author and integrate it. Questions and one-off tasks do not authorize adding a skill.",
       "skillPath": "skills/ca-new-skill/SKILL.md",
       "visibility": "advanced",
       "workflow": "extend",

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

@@ -6,32 +6,32 @@
   "binaries": {
     "darwin/amd64": {
       "file": "ca-artifact-darwin-amd64",
-      "sha256": "fab98b0fd68bafe5f2f52941f704dc32bf623eaa68be18e9e68cc9bc07f05cac",
+      "sha256": "8e2a1f3026d5d9a8de36f3f748a7140ecf1ef8e768022aaa8745884e09551f9a",
       "native_tested": true
     },
     "darwin/arm64": {
       "file": "ca-artifact-darwin-arm64",
-      "sha256": "44211f23050e42ac155432e6d3e3edc58fd7180171a982c6c4a39378ec15218d",
+      "sha256": "cce4b1cd751ada483bffd2de53bd14cdfda50f5d7392b49ba3f020b58fc59da4",
       "native_tested": true
     },
     "linux/amd64": {
       "file": "ca-artifact-linux-amd64",
-      "sha256": "100e36cf452a79fb678ee2f99956953ae97da5b49bc673e77cef094a87bd1cab",
+      "sha256": "7637fe233e8731f4f15ff36b2e80714edd7e6fd96117b41f911d0c8f46639615",
       "native_tested": true
     },
     "linux/arm64": {
       "file": "ca-artifact-linux-arm64",
-      "sha256": "6c1aa70e582e5054c8125cb89585bfd0f0eda6a2b32f3c67c9cdbff76ca78e0f",
+      "sha256": "daa4ed9f1f577c59afd0250701959718f501799c204df01a92f00876c088f619",
       "native_tested": true
     },
     "windows/amd64": {
       "file": "ca-artifact-windows-amd64.exe",
-      "sha256": "6a17e6188fede9f8b8271d0f9eeab41512b58118e5b12781e62b4ce8dc0c5519",
+      "sha256": "16a3a26c5c606fe77703cbc9ae69414cbbe93f2c50dda9301eb9784e2e842206",
       "native_tested": true
     },
     "windows/arm64": {
       "file": "ca-artifact-windows-arm64.exe",
-      "sha256": "746bfd19ed124b14376326b05a435aad381d7a72093f0e8002fa66e186e64194",
+      "sha256": "f64155cd951be94039ea85d4420b2d3bad75ebcb14e68aeb15be8ccf9ec1f690",
       "native_tested": true
     }
   }

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

@@ -15,6 +15,8 @@ import sys
 from typing import Any
 
 import _artifactlib
+import _artifactauthoritylib
+import _artifactpromptlib
 
 
 PENDING = Path(".codearbiter/.markers/pending-user-approval.json")
@@ -150,6 +152,13 @@ def arm_user_approval(
         raise ApprovalError(
             "PENDING_APPROVAL", "resolve or clear the existing approval request first"
         ) from exc
+    try:
+        _artifactpromptlib.register(
+            root, "approval", artifact_id, f"approve {artifact_id} {token}"
+        )
+    except _artifactpromptlib.PromptRouteError:
+        (root / PENDING).unlink()
+        raise
     return {
         "artifact_id": artifact_id,
         "reply": f"approve {artifact_id} {token}",
@@ -182,6 +191,9 @@ def _load_pending(root: Path) -> dict[str, Any] | None:
         return None
     except (OSError, UnicodeError, ValueError) as exc:
         raise ApprovalError("INVALID_PENDING_APPROVAL", "pending approval is unreadable") from exc
+    if isinstance(value, dict) and value.get("format") == "codearbiter.pending-user-approval/0.2.0":
+        import _sprintapprovallib
+        return _sprintapprovallib.validate_pending(value)
     expected = {
         "format", "artifact_id", "kind", "revision", "model_sha256",
         "normative_sha256", "token_sha256",
@@ -216,7 +228,11 @@ def cancel_user_approval(root: str | Path, artifact_id: str) -> dict[str, Any]:
             "PENDING_APPROVAL_MISMATCH",
             "the pending approval request belongs to another artifact",
         )
+    if pending["format"] == "codearbiter.pending-user-approval/0.2.0":
+        import _sprintapprovallib
+        return _sprintapprovallib.cancel(root, pending)
     (root / PENDING).unlink()
+    _artifactpromptlib.unregister(root, "approval", artifact_id)
     return {"artifact_id": artifact_id, "cancelled": True}
 
 
@@ -232,6 +248,9 @@ def consume_user_approval(
     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)
     parts = prompt.split(" ")
     if len(parts) != 3 or parts[0] != "approve" or parts[1] != pending["artifact_id"]:
         return {"matched": False, "approved": False}
@@ -250,7 +269,6 @@ def consume_user_approval(
     _ready(client, current)
 
     event = {
-        "format": "codearbiter.workflow-event/0.1.0",
         "kind": "approval",
         "authority_kind": "user_workflow",
         "subject": {
@@ -264,20 +282,12 @@ def consume_user_approval(
         "payload": {},
         "source_text": prompt,
     }
-    event_bytes = _canonical(event)
-    digest = hashlib.sha256(event_bytes).hexdigest()
-    source_rel = SOURCE_DIR / f"{digest}.json"
-    source = root / source_rel
     try:
-        _write_new(root, source_rel, event_bytes)
-    except FileExistsError:
-        if source.read_bytes() != event_bytes:
-            raise ApprovalError("INVALID_AUTHORITY_SOURCE", "content-addressed source differs")
-
-    captured = client.call(
-        "capture",
-        {"source_ref": source_rel.as_posix(), "source_sha256": digest},
-    )
+        captured = _artifactauthoritylib.capture_user_prompt(
+            root, client, event, host=host, session_id=session_id,
+        )
+    except _artifactauthoritylib.AuthorityError as exc:
+        raise ApprovalError("INVALID_AUTHORITY_SOURCE", str(exc)) from exc
     receipt = captured.get("receipt")
     if not isinstance(receipt, str) or not receipt:
         raise ApprovalError("INVALID_RECEIPT", "capture returned no receipt")
@@ -285,7 +295,7 @@ def consume_user_approval(
         "approve",
         {
             "artifact_id": current["artifact_id"],
-            "operation_id": f"host-user-approval-{digest[:24]}",
+            "operation_id": f"host-user-approval-{hashlib.sha256(_canonical(event)).hexdigest()[:24]}",
             "expected": {
                 "revision": current["revision"],
                 "model_sha256": current["model_sha256"],
@@ -294,11 +304,12 @@ def consume_user_approval(
         },
     )
     (root / PENDING).unlink()
+    _artifactpromptlib.unregister(root, "approval", current["artifact_id"])
     return {
         "matched": True,
         "approved": True,
         "artifact_id": current["artifact_id"],
-        "authority_source": source_rel.as_posix(),
+        "authority_source": captured["authority_source"],
         "receipt": receipt,
         "revision": approved.get("revision"),
     }
@@ -306,17 +317,20 @@ def consume_user_approval(
 
 def consume_from_hook(*, root: str | Path, plugin_root: str | Path, prompt: str,
                       host: str, session_id: str) -> str:
-    if not (Path(root) / PENDING).exists():
-        return ""
     try:
+        routed = _artifactpromptlib.resolve("approval", prompt)
+        root = routed or Path(root)
+        if not (Path(root) / PENDING).exists():
+            return ""
         client = _artifactlib.ArtifactClient(
             root, Path(plugin_root) / "helpers" / "artifacts"
         )
         result = consume_user_approval(
             root, client, prompt, host=host, session_id=session_id
         )
-    except (ApprovalError, _artifactlib.ArtifactError, OSError) as exc:
-        if isinstance(prompt, str) and prompt.startswith("approve "):
+    except (ApprovalError, _artifactlib.ArtifactError,
+            _artifactpromptlib.PromptRouteError, OSError) as exc:
+        if isinstance(prompt, str) and prompt.startswith(("approve ", "approve-sprint ")):
             return f"codeArbiter: approval capture failed: {exc}"
         return ""
     if not result.get("approved"):
@@ -336,6 +350,17 @@ def main(argv: list[str] | None = None) -> int:
     cancel = sub.add_parser("cancel")
     cancel.add_argument("--root", required=True)
     cancel.add_argument("--artifact-id", required=True)
+    pair = sub.add_parser("arm-sprint")
+    pair.add_argument("--root", required=True)
+    pair.add_argument("--spec-id", required=True)
+    pair.add_argument("--plan-id", required=True)
+    pair.add_argument("--delegate-methods", action="store_true")
+    resume = sub.add_parser("resume-sprint")
+    resume.add_argument("--root", required=True)
+    resume.add_argument("--plan-id", required=True)
+    smarts = sub.add_parser("smarts")
+    smarts.add_argument("--root", required=True)
+    smarts.add_argument("--request-file", required=True)
     args = parser.parse_args(argv)
     if args.command == "cancel":
         print(json.dumps(cancel_user_approval(args.root, args.artifact_id)))
@@ -343,13 +368,24 @@ def main(argv: list[str] | None = None) -> int:
     client = _artifactlib.ArtifactClient(
         args.root, _artifactlib.helper_installation(__file__)
     )
-    print(json.dumps(arm_user_approval(args.root, client, args.artifact_id)))
+    if args.command == "smarts":
+        import _sprintapprovallib
+        print(json.dumps(_sprintapprovallib.apply_decision(client, args.request_file)))
+        return 0
+    if args.command in {"arm-sprint", "resume-sprint"}:
+        import _sprintapprovallib
+        result = (_sprintapprovallib.arm(args.root, client, args.spec_id, args.plan_id, delegate_methods=args.delegate_methods)
+                  if args.command == "arm-sprint" else _sprintapprovallib.resume(args.root, client, args.plan_id))
+    else:
+        result = arm_user_approval(args.root, client, args.artifact_id)
+    print(json.dumps(result))
     return 0
 
 
 if __name__ == "__main__":
     try:
         raise SystemExit(main())
-    except (ApprovalError, _artifactlib.ArtifactError) as exc:
+    except (ApprovalError, _artifactlib.ArtifactError,
+            _artifactpromptlib.PromptRouteError) as exc:
         sys.stderr.write(str(exc) + "\n")
         raise SystemExit(1)