@ccoalm/ccl-skills 0.1.0

package/dist/assets/marketplace/plugins/ccl-skills/skills/code-review/scripts/review_gate.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# Provider-neutral review/challenge entrypoint. The Python implementation owns
+# packet freezing and the explicit Claude -> Codex -> Kimi -> OpenCode state machine.
+set -euo pipefail
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+exec python3 "$script_dir/review_gate.py" "$@"

package/dist/assets/marketplace/plugins/ccl-skills/skills/code-review/scripts/run_claude_capture.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import subprocess
+import sys
+
+CAPTURE_SIGNAL_EXIT = 198
+CAPTURE_TIMEOUT_EXIT = 199
+
+
+def main() -> int:
+    if len(sys.argv) < 6:
+        print(
+            "usage: run_claude_capture.py TIMEOUT OUT ERR PROMPT_FILE COMMAND...",
+            file=sys.stderr,
+        )
+        return 64
+
+    timeout_s = float(sys.argv[1])
+    output_file = sys.argv[2]
+    err_file = sys.argv[3]
+    prompt_file = sys.argv[4]
+    cmd = sys.argv[5:]
+
+    try:
+        with open(prompt_file, "r", encoding="utf-8") as fh:
+            prompt = fh.read()
+    except OSError as exc:
+        write_result(output_file, err_file, "", f"failed to read prompt file: {exc}")
+        return 127
+
+    try:
+        result = subprocess.run(
+            cmd,
+            input=prompt,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            timeout=timeout_s,
+            check=False,
+        )
+    except subprocess.TimeoutExpired as exc:
+        stdout = exc.stdout or ""
+        stderr = exc.stderr or ""
+        if isinstance(stdout, bytes):
+            stdout = stdout.decode("utf-8", errors="replace")
+        if isinstance(stderr, bytes):
+            stderr = stderr.decode("utf-8", errors="replace")
+        write_result(output_file, err_file, stdout, stderr)
+        return CAPTURE_TIMEOUT_EXIT
+    except OSError as exc:
+        write_result(output_file, err_file, "", str(exc))
+        return 127
+
+    write_result(output_file, err_file, result.stdout, result.stderr)
+    if result.returncode < 0:
+        with open(err_file, "a", encoding="utf-8") as err:
+            err.write(f"\nClaude process terminated by signal {-result.returncode}\n")
+        return CAPTURE_SIGNAL_EXIT
+    return result.returncode
+
+
+def write_result(output_file: str, err_file: str, stdout: str, stderr: str) -> None:
+    with open(output_file, "w", encoding="utf-8") as out:
+        out.write(stdout)
+    with open(err_file, "w", encoding="utf-8") as err:
+        err.write(stderr)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/assets/marketplace/plugins/ccl-skills/skills/code-review/scripts/runtime-surface-verification-design.md

@@ -0,0 +1,53 @@
+# Formal-invocation runtime verification design
+
+## Decision
+
+Claude and OpenCode do not make a separate model request to test tool behavior.
+A cooperative canary describes only that response, adds latency and cost, and
+cannot turn the wrapper into a hard sandbox. Gate evidence comes from the formal
+review/challenge invocation itself.
+
+Kimi and Codex already follow this shape: each uses one formal invocation and
+audits its own event stream. OpenCode additionally runs the non-inference
+`opencode debug agent ccl-review` command to resolve its configured tool
+surface and optional model before the formal session.
+
+## Claude evidence
+
+The formal Claude stream must contain a parseable `system/init` record. The
+runtime judge requires:
+
+- the exact expected built-in tool set (`StructuredOutput` only for schema-based
+  packet modes; `Read,Grep,Glob` plus `StructuredOutput` for repository consult);
+- empty `mcp_servers`, `slash_commands`, `skills`, and `plugins` lists;
+- only reviewed init metadata fields and values;
+- no tool invocation outside the expected set;
+- a structurally clean result envelope with no error, API status, permission
+  denial, auth, or quota signal.
+
+Missing init evidence, malformed JSONL, unknown fields, unexpected tools, and
+permission denials fail closed. `parse_review_json.py` separately validates the
+review payload and requested mode.
+
+## OpenCode evidence
+
+Before inference, `debug agent ccl-review` must resolve the required read
+tools and explicit `false` values for known write, execution, network,
+interactive, and subagent tools. If it resolves a configured model, the formal
+export must match it. A null model is valid and leaves default selection to the
+user's OpenCode configuration.
+
+The formal run then binds one session ID to one export. Every assistant message
+must use the same provider/model, the exported family must differ from the
+implementer family, and only a stop-finished schema verdict may pass. No probe
+session or probe export exists.
+
+## Verification
+
+- `test_claude_review_probe.sh` asserts one formal invocation and validates its
+  exact argv/runtime surface.
+- `test_parse_probe_result.sh` exercises the stream-init and tool-use judge.
+- `test_opencode_review_retry.sh` asserts one conforming formal invocation and a
+  maximum of two only for bounded format repair.
+- `test_opencode_review_concurrency.sh` proves two wrappers overlap and export
+  exactly their two formal review sessions.

package/dist/assets/marketplace/plugins/ccl-skills/skills/code-review/scripts/test_classify_envelope.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+classifier="$script_dir/classify_envelope.py"
+
+# expect_token PAYLOAD EXPECTED_PREFIX: classifier exits 0 and prints a token
+# starting with EXPECTED_PREFIX.
+expect_token() {
+  local payload="$1" expected="$2" out
+  if ! out="$(printf '%s' "$payload" | python3 "$classifier")"; then
+    printf 'expected classification (exit 0) for: %s\n' "$payload" >&2
+    return 1
+  fi
+  case "$out" in
+    "$expected"*) ;;
+    *)
+      printf 'expected token prefix %q but got %q for: %s\n' "$expected" "$out" "$payload" >&2
+      return 1 ;;
+  esac
+}
+
+# expect_clean PAYLOAD: classifier exits 3 because JSON was present but no
+# error was classified. The caller must not raw-text grep this payload.
+expect_clean() {
+  local payload="$1"
+  set +e
+  printf '%s' "$payload" | python3 "$classifier" >/dev/null 2>&1
+  local rc=$?
+  set -e
+  if [ "$rc" -ne 3 ]; then
+    printf 'expected clean-envelope exit 3 for: %s\n' "$payload" >&2
+    return 1
+  fi
+}
+
+# expect_no_envelope PAYLOAD: classifier exits 1, so the caller may use its
+# startup stderr/text fallback.
+expect_no_envelope() {
+  local payload="$1"
+  set +e
+  printf '%s' "$payload" | python3 "$classifier" >/dev/null 2>&1
+  local rc=$?
+  set -e
+  if [ "$rc" -ne 1 ]; then
+    printf 'expected no-envelope exit 1 for: %s\n' "$payload" >&2
+    return 1
+  fi
+}
+
+expect_token '{"type":"result","subtype":"error","is_error":true,"result":"Not logged in. Please run /login"}' auth
+expect_token '{"type":"result","subtype":"error","is_error":true,"result":"API Error: rate limit exceeded"}' quota:
+expect_token '{"type":"result","subtype":"success","is_error":false,"api_error_status":429,"result":"slow down"}' quota:
+expect_token '{"type":"result","subtype":"success","is_error":false,"permission_denials":["Read"],"result":""}' permission_denied
+expect_token $'{"type":"system","subtype":"init","permissionMode":"default","tools":[]}\n{"type":"result","subtype":"success","is_error":false,"permission_denials":["Read"],"result":""}' permission_denied
+expect_token '{"type":"result","subtype":"error_during_execution","is_error":false,"result":"boom"}' error:error_during_execution
+expect_token '{"type":"result","subtype":"error_max_turns","is_error":false,"result":""}' error:error_max_turns
+
+# A clean success envelope is not an error -> passthrough (handled by parser).
+expect_clean '{"type":"result","subtype":"success","is_error":false,"permission_denials":[],"structured_output":{"mode":"challenge","findings":[]}}'
+expect_clean '{"type":"result","subtype":"success","is_error":false,"result":"The reviewed code mentions rate limit exceeded and not logged in."}'
+# Bare review JSON (no envelope) -> passthrough.
+expect_clean '{"mode":"challenge","findings":[]}'
+# Non-JSON prose -> passthrough (caller does the stderr text fallback).
+expect_no_envelope 'Not logged in'
+expect_no_envelope ''
+
+printf 'classify_envelope_tests_ok\n'