dsh-compound-engineering 0.0.0-stage → 0.1.0

package/skills/ce-resolve-pr-feedback/scripts/get-pr-comments

@@ -0,0 +1,176 @@
+#!/usr/bin/env bash
+
+set -e
+
+if [ $# -lt 1 ]; then
+    echo "Usage: get-pr-comments PR_NUMBER [OWNER/REPO]"
+    echo "Example: get-pr-comments 123"
+    echo "Example: get-pr-comments 123 EveryInc/cora"
+    exit 1
+fi
+
+PR_NUMBER=$1
+
+if [ -n "$2" ]; then
+    OWNER=$(echo "$2" | cut -d/ -f1)
+    REPO=$(echo "$2" | cut -d/ -f2)
+else
+    # `|| true` is load-bearing: under `set -e`, a failed command substitution
+    # in an assignment aborts the script immediately. Run outside a git repo,
+    # `gh repo view` exits 1, its stderr is swallowed by `2>/dev/null`, and the
+    # script would die here with rc=1 and no output -- making the friendly error
+    # below unreachable. Keep `|| true` so detection failure falls through to it.
+    OWNER=$(gh repo view --json owner -q .owner.login 2>/dev/null || true)
+    REPO=$(gh repo view --json name -q .name 2>/dev/null || true)
+fi
+
+if [ -z "$OWNER" ] || [ -z "$REPO" ]; then
+    echo "Error: could not resolve owner/repo. Run get-pr-comments from inside the target git repository, or pass OWNER/REPO as the second argument (e.g., get-pr-comments $PR_NUMBER EveryInc/cora)." >&2
+    exit 1
+fi
+
+# Output is a JSON object with these keys:
+#   pending_review   - node ID of the viewer's own unsubmitted (PENDING) review
+#                      on this PR, or null. Replies posted while one exists get
+#                      silently absorbed into that draft and stay invisible
+#                      until it is submitted, so the modes must stop before the
+#                      reply loop when this is non-null. Costs no extra request:
+#                      the reviews query below already selects `state`, and a
+#                      PENDING review is only visible to its own author.
+#   review_threads   - unresolved inline review threads, edge-wrapped with the
+#                      root numeric REST comment ID used for direct replies:
+#                      [{ root_comment_id, node: { id, isResolved, ... } }]
+#   pr_comments      - non-empty top-level PR conversation comments
+#   review_bodies    - non-empty review submission bodies
+#   pr_author        - the PR author's login, or null
+#   viewer           - the acting account's login, or null
+#
+# Pagination (issue #798): each top-level connection -- reviewThreads,
+# comments, reviews -- is fetched in its own paginated query because
+# `gh api graphql --paginate` only follows the outermost pageInfo per
+# response. Combining them into one query (as this script previously did)
+# silently dropped everything past page 1 on long-lived PRs and made the
+# skill report "0 of 0 resolved" while real findings sat unanswered.
+# Per-thread inline `comments` are fetched up to 100 per thread without
+# follow-up pagination; threads that exceed 100 comments are rare and out of
+# scope for this fix.
+#
+# Content, identity, and surface are evidence for the resolver, not deterministic
+# exclusions. CI/status bots can carry actionable setup or posting failures, and
+# automation identities can transport human-authored reviews -- and an author
+# posting on their own PR is the ordinary way a human asks an agent-opened PR
+# for a change (#1435 eval: every run silently dropped "please rename check_id"
+# because this fetch excluded it before the skill could judge it). So the only
+# exclusion here is a blank body; `pr_author` and `viewer` are reported so the
+# resolver can weigh identity as evidence, including recognizing its own prior
+# replies as already-handled.
+
+tmp_threads=$(mktemp "${TMPDIR:-/tmp}/ce-pr-threads.XXXXXX")
+tmp_comments=$(mktemp "${TMPDIR:-/tmp}/ce-pr-comments.XXXXXX")
+tmp_reviews=$(mktemp "${TMPDIR:-/tmp}/ce-pr-reviews.XXXXXX")
+trap 'rm -f "$tmp_threads" "$tmp_comments" "$tmp_reviews"' EXIT
+
+gh api graphql --paginate --slurp \
+  -f owner="$OWNER" -f repo="$REPO" -F pr="$PR_NUMBER" \
+  -f query='
+query Threads($owner: String!, $repo: String!, $pr: Int!, $endCursor: String) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      author { login }
+      reviewThreads(first: 100, after: $endCursor) {
+        nodes {
+          id
+          isResolved
+          isOutdated
+          path
+          line
+          originalLine
+          startLine
+          originalStartLine
+          comments(first: 100) {
+            nodes {
+              id
+              author { login }
+              body
+              createdAt
+              url
+            }
+          }
+        }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+}' > "$tmp_threads"
+
+gh api graphql --paginate --slurp \
+  -f owner="$OWNER" -f repo="$REPO" -F pr="$PR_NUMBER" \
+  -f query='
+query Comments($owner: String!, $repo: String!, $pr: Int!, $endCursor: String) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      comments(first: 100, after: $endCursor) {
+        nodes {
+          id
+          author { login }
+          body
+        }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+}' > "$tmp_comments"
+
+gh api graphql --paginate --slurp \
+  -f owner="$OWNER" -f repo="$REPO" -F pr="$PR_NUMBER" \
+  -f query='
+query Reviews($owner: String!, $repo: String!, $pr: Int!, $endCursor: String) {
+  viewer { login }
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      reviews(first: 100, after: $endCursor) {
+        nodes {
+          id
+          author { login }
+          body
+          state
+        }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+}' > "$tmp_reviews"
+
+# Resolution semantics: `isOutdated` means the diff hunk around the comment
+# has shifted since the thread was opened -- not that the reviewer concern
+# was addressed. Resolution state is the only authoritative signal; outdated
+# threads are still surfaced (with their isOutdated flag intact) so the
+# resolver can factor in that the referenced line may have moved.
+jq -n \
+  --slurpfile threads "$tmp_threads" \
+  --slurpfile comments "$tmp_comments" \
+  --slurpfile reviews "$tmp_reviews" '
+  ($threads[0][0].data.repository.pullRequest.author) as $author |
+  [$threads[0][].data.repository.pullRequest.reviewThreads.nodes[]] as $all_threads |
+  [$comments[0][].data.repository.pullRequest.comments.nodes[]] as $all_comments |
+  [$reviews[0][].data.repository.pullRequest.reviews.nodes[]] as $all_reviews |
+  [$all_threads[] | select(.isResolved == false)] as $unresolved |
+  ($reviews[0][0].data.viewer.login) as $viewer |
+  {
+    pending_review: (first($all_reviews[]
+      | select(.state == "PENDING")
+      | select(($viewer == null) or (.author.login == $viewer))
+      | .id) // null),
+    review_threads: [$unresolved[] | {
+      node: .,
+      root_comment_id: (.comments.nodes[0].url
+        | capture("discussion_r(?<id>[0-9]+)").id
+        | tonumber)
+    }],
+    pr_comments: [$all_comments[]
+      | select((.body // "") | test("^\\s*$") | not)],
+    review_bodies: [$all_reviews[]
+      | select((.body // "") | test("^\\s*$") | not)],
+    pr_author: ($author.login // null),
+    viewer: ($viewer // null)
+  }'

package/skills/ce-resolve-pr-feedback/scripts/get-thread-for-comment

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+
+# Maps a PR review comment node ID to its parent thread.
+# Fetches all review threads (paginated) and their comments, then returns the
+# thread whose comments contain the target ID.
+
+set -e
+
+if [ $# -lt 2 ]; then
+    echo "Usage: get-thread-for-comment PR_NUMBER COMMENT_NODE_ID [OWNER/REPO]"
+    echo "Example: get-thread-for-comment 378 PRRC_kwDOP_gZVc6ySv89"
+    exit 1
+fi
+
+PR_NUMBER=$1
+COMMENT_NODE_ID=$2
+
+if [ -n "$3" ]; then
+    OWNER=$(echo "$3" | cut -d/ -f1)
+    REPO=$(echo "$3" | cut -d/ -f2)
+else
+    # `|| true` is load-bearing: under `set -e`, a failed command substitution
+    # in an assignment aborts the script immediately. Run outside a git repo,
+    # `gh repo view` exits 1, its stderr is swallowed by `2>/dev/null`, and the
+    # script would die here with rc=1 and no output -- making the friendly error
+    # below unreachable. Keep `|| true` so detection failure falls through to it.
+    OWNER=$(gh repo view --json owner -q .owner.login 2>/dev/null || true)
+    REPO=$(gh repo view --json name -q .name 2>/dev/null || true)
+fi
+
+if [ -z "$OWNER" ] || [ -z "$REPO" ]; then
+    echo "Error: could not resolve owner/repo. Run get-thread-for-comment from inside the target git repository, or pass OWNER/REPO as the third argument (e.g., get-thread-for-comment $PR_NUMBER $COMMENT_NODE_ID EveryInc/cora)." >&2
+    exit 1
+fi
+
+# Pagination (issue #798): paginate the reviewThreads connection so PRs with
+# more than one page of threads can still resolve a comment to its parent
+# thread. Per-thread comments are still capped at 100 -- threads exceeding
+# that depth are not paginated here.
+tmp_threads=$(mktemp "${TMPDIR:-/tmp}/ce-pr-threads.XXXXXX")
+trap 'rm -f "$tmp_threads"' EXIT
+
+gh api graphql --paginate --slurp \
+  -f owner="$OWNER" -f repo="$REPO" -F pr="$PR_NUMBER" \
+  -f query='
+query Threads($owner: String!, $repo: String!, $pr: Int!, $endCursor: String) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      reviewThreads(first: 100, after: $endCursor) {
+        nodes {
+          id
+          isResolved
+          isOutdated
+          path
+          line
+          originalLine
+          startLine
+          originalStartLine
+          comments(first: 100) {
+            nodes {
+              id
+              author { login }
+              body
+              createdAt
+              url
+            }
+          }
+        }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+}' > "$tmp_threads"
+
+jq -e -n --slurpfile pages "$tmp_threads" --arg cid "$COMMENT_NODE_ID" '
+  [$pages[0][].data.repository.pullRequest.reviewThreads.nodes[]
+   | select(any(.comments.nodes[]; .id == $cid))]
+  | if length == 0 then error("No thread found for comment \($cid)") else .[0] end
+  | . + {
+      root_comment_id: (.comments.nodes[0].url
+        | capture("discussion_r(?<id>[0-9]+)").id
+        | tonumber)
+    }
+'

package/skills/ce-resolve-pr-feedback/scripts/pending-feedback.py

@@ -0,0 +1,287 @@
+"""Preserve a judged feedback batch. This helper never mutates GitHub."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from urllib.parse import urlsplit
+
+
+SCHEMA_VERSION = 1
+VERDICTS = {"fixed", "fixed-differently", "replied", "not-addressing", "declined", "needs-human"}
+KINDS = {"thread", "comment", "review"}
+
+
+def require(condition: bool, message: str) -> None:
+    if not condition:
+        raise ValueError(message)
+
+
+def string(value: object, name: str, pattern: str | None = None) -> str:
+    require(isinstance(value, str) and bool(value), f"{name} must be a nonempty string")
+    if pattern:
+        require(re.fullmatch(pattern, value) is not None, f"invalid {name}")
+    return value
+
+
+def positive_int(value: object, name: str) -> None:
+    require(type(value) is int and value > 0, f"{name} must be a positive integer")
+
+
+def object_value(value: object, name: str) -> dict:
+    require(isinstance(value, dict), f"{name} must be an object")
+    return value
+
+
+def array(value: object, name: str) -> list:
+    require(isinstance(value, list), f"{name} must be an array")
+    return value
+
+
+def decision(value: object) -> None:
+    context = object_value(value, "decision_context")
+    for key in ("quoted_feedback", "investigation", "decision_reason"):
+        string(context.get(key), key)
+    options = array(context.get("options"), "options")
+    require(bool(options), "decision options must not be empty")
+    for option in options:
+        option = object_value(option, "option")
+        string(option.get("option"), "option")
+        string(option.get("tradeoff"), "tradeoff")
+    require("recommendation" in context, "missing recommendation")
+    if context["recommendation"] is not None:
+        string(context["recommendation"], "recommendation")
+
+
+def progress(value: object) -> None:
+    value = object_value(value, "progress")
+    require(set(value) <= {"reply_id", "reply_url", "resolved", "applied"}, "unknown progress field")
+    if "reply_id" in value:
+        positive_int(value["reply_id"], "reply_id")
+    if "reply_url" in value:
+        string(value["reply_url"], "reply_url")
+    for key in ("resolved", "applied"):
+        if key in value:
+            require(type(value[key]) is bool, f"{key} must be boolean")
+
+
+def validate(record: object) -> dict:
+    record = object_value(record, "record")
+    require(type(record.get("schema_version")) is int and record["schema_version"] == SCHEMA_VERSION, "unsupported schema_version")
+    require(record.get("status") in {"pending", "completed"}, "invalid status")
+    pr = object_value(record.get("pr"), "pr")
+    host = string(pr.get("host"), "host", r"[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?(?::[0-9]+)?")
+    for key in ("base_repo", "head_repo"):
+        string(pr.get(key), key, r"[A-Za-z0-9_-][A-Za-z0-9_.-]*/(?!\.{1,2}$)[A-Za-z0-9_.-]+")
+    positive_int(pr.get("number"), "PR number")
+    expected_url = f"https://{host}/{pr['base_repo']}/pull/{pr['number']}"
+    require(pr.get("url") == expected_url, "PR URL does not match host/base/number")
+    ref = string(pr.get("head_ref"), "head_ref")
+    require(not re.search(r"[\x00-\x20\x7f~^:?*\[\\]", ref) and not any(token in ref for token in ("..", "@{")), "invalid head_ref")
+    require(not ref.startswith(("-", "/", ".")) and not ref.endswith(("/", ".", ".lock")) and "//" not in ref, "invalid head_ref")
+    require("fix_commit" in record, "missing fix_commit")
+    if record["fix_commit"] is not None:
+        string(record["fix_commit"], "fix_commit", r"[0-9a-f]{40}")
+    verification = object_value(record.get("verification"), "verification")
+    require(verification.get("outcome") in {"passed", "pre-existing-failure", "failed", "not-run"}, "invalid verification outcome")
+    for key in ("command", "details"):
+        require(isinstance(verification.get(key), str), f"verification.{key} must be a string")
+    seen = set()
+    for action in array(record.get("actions"), "actions"):
+        action = object_value(action, "action")
+        source = object_value(action.get("source"), "source")
+        require(source.get("kind") in KINDS, "invalid source kind")
+        source_id = string(source.get("id"), "source id", r"[A-Za-z0-9_+=:-]+")
+        key = (source["kind"], source_id)
+        require(key not in seen, "duplicate source identity")
+        seen.add(key)
+        url = urlsplit(string(source.get("url"), "source URL"))
+        require(url.scheme == "https" and url.netloc == host and url.path.rstrip("/") == f"/{pr['base_repo']}/pull/{pr['number']}" and not url.query, "source URL does not belong to PR")
+        string(source.get("body_sha256"), "body_sha256", r"[0-9a-f]{64}")
+        require(action.get("verdict") in VERDICTS, "invalid verdict")
+        string(action.get("reply_body"), "reply_body")
+        require(type(action.get("resolve")) is bool, "resolve must be boolean")
+        require(action["resolve"] == (source["kind"] == "thread" and action["verdict"] != "needs-human"), "resolve must match the source kind and verdict")
+        if source["kind"] == "thread":
+            positive_int(action.get("root_comment_id"), "root_comment_id")
+            string(action.get("thread_id"), "thread_id", r"[A-Za-z0-9_+=:-]+")
+        else:
+            require(action.get("root_comment_id") is None and action.get("thread_id") is None and not action["resolve"], "non-thread action cannot resolve")
+        if action["verdict"] == "needs-human":
+            require(not action["resolve"], "needs-human action cannot resolve")
+            decision(action.get("decision_context"))
+        else:
+            require(action.get("decision_context") is None, "decision_context belongs to needs-human")
+        require("invariant_key" in action, "missing invariant_key")
+        if action["invariant_key"] is not None:
+            string(action["invariant_key"], "invariant_key", r"[A-Za-z0-9._:-]{1,120}")
+        if "progress" in action:
+            progress(action["progress"])
+        if record["status"] == "completed":
+            observed = action.get("progress", {})
+            positive_int(observed.get("reply_id"), "completed action reply_id")
+            require(not action["resolve"] or observed.get("resolved") is True, "completed action must have its required resolution")
+    for tick in array(record.get("body_ticks"), "body_ticks"):
+        tick = object_value(tick, "body tick")
+        original = string(tick.get("original"), "original checklist bullet")
+        require(original.startswith("- [ ] ") and "\n" not in original and "\r" not in original, "invalid checklist bullet")
+        require(tick.get("checked") == original.replace("- [ ] ", "- [x] ", 1), "body tick must only check the saved bullet")
+        if "progress" in tick:
+            progress(tick["progress"])
+        if record["status"] == "completed":
+            require(tick.get("progress", {}).get("applied") is True, "completed body tick must be applied")
+    for residual in array(record.get("residuals"), "residuals"):
+        residual = object_value(residual, "residual")
+        require(residual.get("type") == "needs-human", "invalid residual type")
+        sources = array(residual.get("sources"), "residual sources")
+        require(bool(sources), "residual sources must not be empty")
+        for source in sources:
+            source = object_value(source, "residual source")
+            require(source.get("kind") in KINDS, "invalid residual source kind")
+            string(source.get("id"), "residual source id", r"[A-Za-z0-9_+=:-]+")
+        decision(residual.get("decision_context"))
+        thread_urls = array(residual.get("thread_urls"), "thread_urls")
+        require(not any(source["kind"] == "thread" for source in sources) or bool(thread_urls), "thread residual must carry thread_urls")
+        for url in thread_urls:
+            string(url, "thread URL")
+    return record
+
+
+def unique_keys(pairs: list) -> dict:
+    result = {}
+    for key, value in pairs:
+        require(key not in result, f"duplicate JSON key: {key}")
+        result[key] = value
+    return result
+
+
+def reject_constant(value: str) -> None:
+    raise ValueError(f"invalid JSON constant: {value}")
+
+
+def read_record(path: Path) -> tuple[dict, bytes]:
+    raw = path.read_bytes()
+    record = json.loads(raw.decode("utf-8"), object_pairs_hook=unique_keys,
+                        parse_constant=reject_constant)
+    return validate(record), raw
+
+
+def prepared_content(record: dict) -> dict:
+    return {
+        "schema_version": record["schema_version"],
+        "pr": record["pr"], "fix_commit": record["fix_commit"], "verification": record["verification"],
+        "actions": [{key: value for key, value in action.items() if key != "progress"} for action in record["actions"]],
+        "body_ticks": [{key: value for key, value in tick.items() if key != "progress"} for tick in record["body_ticks"]],
+        "residuals": record["residuals"],
+    }
+
+
+def write_record(path: Path, raw: bytes, *, checkpoint: bool) -> None:
+    if checkpoint:
+        temporary = None
+        try:
+            with tempfile.NamedTemporaryFile(dir=path.parent, prefix=".pending-feedback-", delete=False) as temp:
+                temporary = Path(temp.name)
+                temp.write(raw)
+                temp.flush()
+                os.fsync(temp.fileno())
+            os.replace(temporary, path)
+        finally:
+            if temporary is not None:
+                temporary.unlink(missing_ok=True)
+    else:
+        descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+        with os.fdopen(descriptor, "wb") as target:
+            target.write(raw)
+            target.flush()
+            os.fsync(target.fileno())
+    read_record(path)
+
+
+def github_json(host: str, endpoint: str) -> dict:
+    result = subprocess.run(
+        ["gh", "api", "--hostname", host, "--method", "GET", endpoint],
+        capture_output=True, text=True, check=False,
+    )
+    require(result.returncode == 0, result.stderr.strip() or f"GitHub GET failed: {endpoint}")
+    return object_value(json.loads(result.stdout), "GitHub response")
+
+
+def inspect_publication(record: dict) -> dict:
+    proof = {"verified": False, "reason": "", "head_sha": None,
+             "head_repo": None, "head_ref": None, "comparison_status": None}
+    pr = record["pr"]
+    try:
+        fresh = github_json(pr["host"], f"repos/{pr['base_repo']}/pulls/{pr['number']}")
+        require(fresh.get("number") == pr["number"] and fresh.get("html_url") == pr["url"],
+                "fresh PR host/number/URL differs from the saved PR")
+        base = object_value(fresh.get("base"), "fresh base")
+        require(object_value(base.get("repo"), "fresh base repository").get("full_name") == pr["base_repo"],
+                "fresh PR base repository differs from the saved PR")
+        head = object_value(fresh.get("head"), "fresh head")
+        proof["head_repo"] = object_value(head.get("repo"), "fresh head repository").get("full_name")
+        proof["head_ref"] = head.get("ref")
+        proof["head_sha"] = string(head.get("sha"), "fresh head SHA", r"[0-9a-f]{40}")
+        require(proof["head_repo"] == pr["head_repo"] and proof["head_ref"] == pr["head_ref"],
+                "fresh PR head repository/ref differs from the saved PR")
+        commit = record["fix_commit"]
+        if commit is None:
+            proof.update(verified=True, reason="saved batch created no fix commit")
+            return proof
+        comparison = github_json(pr["host"], f"repos/{proof['head_repo']}/compare/{commit}...{proof['head_sha']}")
+        proof["comparison_status"] = comparison.get("status")
+        merge_base = object_value(comparison.get("merge_base_commit"), "comparison merge base")
+        require(proof["comparison_status"] in {"ahead", "identical"} and merge_base.get("sha") == commit,
+                "recorded fix commit is not positively reachable from the fresh PR head")
+        proof.update(verified=True, reason="recorded fix commit is reachable from the fresh PR head")
+    except (OSError, ValueError, TypeError) as error:
+        proof["reason"] = str(error)
+    return proof
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subcommands = parser.add_subparsers(dest="command", required=True)
+    preflight = subcommands.add_parser("preflight")
+    preflight.add_argument("--path")
+    for command in ("create", "validate", "checkpoint", "inspect-publication"):
+        command_parser = subcommands.add_parser(command)
+        command_parser.add_argument("--path", required=True)
+        if command in {"create", "checkpoint"}:
+            command_parser.add_argument("--input", required=True)
+    args = parser.parse_args()
+    if args.command == "preflight":
+        path = Path(args.path).absolute() if args.path else Path(tempfile.mkdtemp(prefix="ce-pending-feedback-")) / "pending.json"
+        require(not os.path.lexists(path), "handoff destination already exists")
+        require(path.parent.is_dir(), "handoff parent directory does not exist")
+        with tempfile.TemporaryFile(dir=path.parent):
+            pass
+        print(json.dumps({"handoff": str(path)}))
+        return
+    path = Path(args.path).absolute()
+    if args.command in {"validate", "inspect-publication"}:
+        record, _ = read_record(path)
+    else:
+        record, raw = read_record(Path(args.input))
+        if args.command == "checkpoint":
+            previous, _ = read_record(path)
+            require(prepared_content(previous) == prepared_content(record), "checkpoint cannot replace the prepared batch")
+        write_record(path, raw, checkpoint=args.command == "checkpoint")
+    output = {"handoff": str(path), "record": record}
+    if args.command == "inspect-publication":
+        output["publication"] = inspect_publication(record)
+    print(json.dumps(output, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (OSError, ValueError, TypeError) as error:
+        print(f"pending feedback: {error}", file=sys.stderr)
+        sys.exit(1)

package/skills/ce-resolve-pr-feedback/scripts/reply-to-pr-thread

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+
+# Replies directly to a PR review thread's root comment. Body is read from
+# stdin to preserve Markdown quotes and newlines. The REST reply endpoint is
+# load-bearing: GraphQL addPullRequestReviewThreadReply can attach the reply to
+# a pending review and return success before the reply is submitted or visible.
+
+set -e
+
+if [ $# -lt 2 ]; then
+    echo "Usage: reply-to-pr-thread PR_NUMBER ROOT_COMMENT_ID [OWNER/REPO] < reply-body.md"
+    echo "Example: reply-to-pr-thread 123 456789 EveryInc/cora < reply-body.md"
+    exit 1
+fi
+
+PR_NUMBER=$1
+ROOT_COMMENT_ID=$2
+IFS= read -r -d '' BODY || true
+
+if [ -n "$3" ]; then
+    OWNER=$(echo "$3" | cut -d/ -f1)
+    REPO=$(echo "$3" | cut -d/ -f2)
+else
+    OWNER=$(gh repo view --json owner -q .owner.login 2>/dev/null || true)
+    REPO=$(gh repo view --json name -q .name 2>/dev/null || true)
+fi
+
+if [ -z "$OWNER" ] || [ -z "$REPO" ]; then
+    echo "Error: could not resolve owner/repo. Pass OWNER/REPO as the third argument." >&2
+    exit 1
+fi
+
+case "$PR_NUMBER" in
+    ''|*[!0-9]*) echo "Error: PR_NUMBER must be numeric." >&2; exit 1 ;;
+esac
+
+case "$ROOT_COMMENT_ID" in
+    ''|*[!0-9]*) echo "Error: ROOT_COMMENT_ID must be numeric." >&2; exit 1 ;;
+esac
+
+if [ -z "$BODY" ]; then
+    echo "Error: No body provided on stdin."
+    exit 1
+fi
+
+gh api --method POST \
+  "repos/$OWNER/$REPO/pulls/$PR_NUMBER/comments/$ROOT_COMMENT_ID/replies" \
+  -f body="$BODY"
+
+PENDING_REVIEW=$(gh api --paginate \
+  "repos/$OWNER/$REPO/pulls/$PR_NUMBER/reviews" \
+  --jq '.[] | select(.state == "PENDING") | .id')
+
+if [ -n "$PENDING_REVIEW" ]; then
+    echo "Error: a pending review appeared after posting. Stop without resolving the thread; do not submit or discard the review." >&2
+    exit 2
+fi

package/skills/ce-resolve-pr-feedback/scripts/resolve-pr-thread

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+set -e
+
+if [ $# -eq 0 ]; then
+    echo "Usage: resolve-pr-thread THREAD_ID"
+    echo "Example: resolve-pr-thread PRRT_kwDOABC123"
+    exit 1
+fi
+
+THREAD_ID=$1
+
+gh api graphql -f threadId="$THREAD_ID" -f query='
+mutation ResolveReviewThread($threadId: ID!) {
+  resolveReviewThread(input: {threadId: $threadId}) {
+    thread {
+      id
+      isResolved
+      path
+      line
+    }
+  }
+}'

package/skills/ce-retune/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: ce-retune
+description: "Retune a skill corpus for a new model, measurement-first: mine the run archive for a baseline, establish a noise floor, audit the corpus adversarially, then cut in measured passes until a pre-registered bar clears. Requires a benchmark harness that can A/B two builds of the corpus; refuses without one."
+disable-model-invocation: true
+argument-hint: "[target model or symptom] [path to the corpus, defaults to ./skills] [bar:<n> consecutive clean runs]"
+---
+
+# Retune a Corpus for a New Model
+
+A corpus that degrades on a new model is a measurement problem before it is a writing problem: rewriting what looks wrong produces a plausible fix list and no way to know whether any item mattered.
+
+**Outcome:** a corpus whose measured behavior on the target model clears a bar registered before any change, with the regression classes removed and each removal attributable.
+
+**Done:** the bar is cleared, or the run reports the specific claim it could not support. A green test suite is not done: it proves nothing broke, not that behavior improved.
+
+**Non-goal:** word reduction. Leanness and performance are separate programs that share a corpus; only one of them is the result here. Report completion, not word count.
+
+
+## Phase 0: the measurement gate — check this first
+
+This skill cannot run without a way to observe behavior. Check for all three, and name whichever is missing:
+
+1. **A run archive or a harness that produces one** — per-run logs carrying the tool-call trace, a terminal marker, token counts, and the final message.
+2. **A build selector** — the harness can point a run at a specific source checkout of the corpus (a `--plugin-dir`-style override, a configurable skills path, an env var), so two builds are comparable under one runner.
+3. **A repeatable task** the corpus actually executes end to end.
+
+If any is missing, **stop and say so**, naming what to build. Do not fall back to a static audit and present it as retuning: an audit can say what looks cuttable and never whether cutting helped. An audit-only pass is a legitimate thing to want; it is a different request.
+
+State the target model and the harness you found before continuing.
+
+## The phases
+
+They run in order, and each names the reference it cannot start without. Read `references/workflow-shapes.md` before dispatching any phase: the wrong orchestration shape is the common failure. Fan out by disjoint file ownership, never by item. Items cross files, and agents that share a file lose each other's edits.
+
+Before assessing whether the registered bar is met or interpreting its results, read `references/noise-floor.md`.
+
+1. **Mine the archive** before spending a run — `references/baseline-mining.md`. Historical runs are a free baseline, usually larger than any experiment affordable now.
+2. **Establish the noise floor** — `references/noise-floor.md`. Run the harness against **two identical copies** of the corpus, same commit on both sides; whatever difference appears is the floor every later claim must clear. **Register the bar now, in writing, before any change exists.** A bar chosen after seeing results is not a bar.
+3. **Audit the corpus adversarially** — `references/corpus-audit.md`. One agent per skill proposes cuts; a second per skill does the opposite and defends the existing prose. **The two passes require independent contexts.** If the host exposes no way to run them as separate agents, report that as a blocker and stop the audit — do not argue both sides in one context and present the result as an audit.
+4. **Cut in surgical passes**, one problem per agent — `references/cut-passes.md`, and `references/halt-taxonomy.md` when the symptom is stalling, halting, or a run that ends while naming work it did not do. Two rules bound every pass, whatever class it is cutting. **Never edit a test to make a suite green**: a removed string a test pins is a finding to report, not a test to weaken. And **not every stop is the enemy.** Some workflows exist to stop and ask; that is the product. Sort every stop by who is actually on the other side before touching it. `references/halt-taxonomy.md` carries the screens that decide, so read them before cutting any stop.
+5. **Measure, then let the failure choose the next fix** — `references/cut-passes.md` again for what each failure site means and for auditing the phases the instrument never enters. Loop 4 and 5 until the registered bar clears. Then stop; a bar cleared is done. Also report what stayed unmeasured: a cleared bar never implies coverage it does not have.
+6. **Ship** — `references/cut-passes.md` carries what the commits and the write-up must preserve.