@dynamicagents/plugins 0.13.0 → 0.15.0

package/dist/{repo → repo-github}/tools-pr.js

@@ -1,10 +1,10 @@
 import { action } from "@cloudflare/think";
 import { tool } from "ai";
 import { z } from "zod";
-import { actionTask, GITHUB_ACTION_TIMEOUT_MS, GITHUB_PAGE_SIZE, sha256 } from "./context.js";
-/** GitHub's REST surface: pull requests, issues and their comments. */
+import { sha256Hex } from "@dynamicagents/core";
+import { actionTask, GITHUB_ACTION_TIMEOUT_MS, GITHUB_PAGE_SIZE } from "./context.js";
 export function prTools(ctx) {
-    const { bounded, github, githubRepo } = ctx;
+    const { bounded, github, mcp, githubRepo } = ctx;
     return {
         repo_open_pr: tool({
             description: "Open a pull request for a pushed branch and return its URL. Do this once the branch is pushed and the tests pass.",
@@ -67,14 +67,31 @@ export function prTools(ctx) {
                 if ("refusal" in target)
                     return target.refusal;
                 const { owner, repo } = target;
-                // The issues endpoint, deliberately, even for a pull request: GitHub
-                // models every PR as an issue, and this is the one that carries the
-                // discussion. `repo_pr_view` is for the parts that are only a PR's.
-                const issue = await github("repo_issue_view", `/repos/${owner}/${repo}/issues/${number}`);
+                const where = {
+                    owner: decodeURIComponent(owner),
+                    repo: decodeURIComponent(repo)
+                };
+                // `issue_read` deliberately, even for a pull request: GitHub models
+                // every PR as an issue, and that is the view carrying the discussion.
+                // `repo_pr_view` is for the parts that are only a PR's.
+                const issue = await mcp("repo_issue_view", "issue_read", {
+                    ...where,
+                    issue_number: number,
+                    method: "get"
+                });
                 if (!issue.ok)
                     return bounded(issue.message);
                 const data = issue.data;
-                const comments = await github("repo_issue_view", `/repos/${owner}/${repo}/issues/${number}/comments?per_page=${GITHUB_PAGE_SIZE}`);
+                // No `pull_request` key on this read, so the kind comes from the URL
+                // GitHub builds for it: a pull request's is `/pull/<n>` where an
+                // issue's is `/issues/<n>`.
+                const isPull = /\/pull\/\d+/.test(data.html_url ?? "");
+                const comments = await mcp("repo_issue_view", "issue_read", {
+                    ...where,
+                    issue_number: number,
+                    method: "get_comments",
+                    perPage: GITHUB_PAGE_SIZE
+                });
                 // A failure here is not a failure of the tool: the issue itself was
                 // read, and half an answer beats none.
                 const thread = (comments.ok && Array.isArray(comments.data) ? comments.data : []);
@@ -85,7 +102,7 @@ export function prTools(ctx) {
                 const moreComments = thread.length >= GITHUB_PAGE_SIZE;
                 return bounded([
                     `#${number} ${data.title ?? "(no title)"} [${data.state ?? "?"}]` +
-                        (data.pull_request ? " (pull request)" : ""),
+                        (isPull ? " (pull request)" : ""),
                     `opened by ${data.user?.login ?? "unknown"}`,
                     "",
                     data.body?.trim() || "(no description)",
@@ -101,7 +118,7 @@ export function prTools(ctx) {
             }
         }),
         repo_pr_view: tool({
-            description: "Read a pull request's state and the files it touches — whether it is mergeable, its review state, and which paths changed. Use this to check on a pull request you opened, or to see what an existing one does before duplicating it.",
+            description: "Read a pull request's state, the reviews that have landed on it, and the files it touches — whether it is mergeable, who has reviewed and with what verdict, and which paths changed. Use this to check on a pull request you opened, to see whether a review has arrived before reading its threads, or to see what an existing one does before duplicating it.",
             inputSchema: z.object({
                 dir: z.string().describe("The checkout directory"),
                 number: z.number().int().positive().describe("Pull request number")
@@ -111,28 +128,76 @@ export function prTools(ctx) {
                 if ("refusal" in target)
                     return target.refusal;
                 const { owner, repo } = target;
-                const pr = await github("repo_pr_view", `/repos/${owner}/${repo}/pulls/${number}`);
+                const where = {
+                    owner: decodeURIComponent(owner),
+                    repo: decodeURIComponent(repo),
+                    pullNumber: number
+                };
+                const pr = await mcp("repo_pr_view", "pull_request_read", {
+                    ...where,
+                    method: "get"
+                });
                 if (!pr.ok)
                     return bounded(pr.message);
                 const data = pr.data;
-                const files = await github("repo_pr_view", `/repos/${owner}/${repo}/pulls/${number}/files?per_page=${GITHUB_PAGE_SIZE}`);
+                const files = await mcp("repo_pr_view", "pull_request_read", {
+                    ...where,
+                    method: "get_files",
+                    perPage: GITHUB_PAGE_SIZE
+                });
                 const changed = (files.ok && Array.isArray(files.data) ? files.data : []);
                 const moreFiles = changed.length >= GITHUB_PAGE_SIZE;
+                // The reviews, because "has one landed yet" is the question an agent
+                // watching a pull request between sessions actually has, and an empty
+                // list of threads does not answer it: a review can finish having left
+                // no comments.
+                const reviews = await mcp("repo_pr_view", "pull_request_read", {
+                    ...where,
+                    method: "get_reviews",
+                    perPage: GITHUB_PAGE_SIZE
+                });
+                const landed = (reviews.ok && Array.isArray(reviews.data) ? reviews.data : []);
+                // A draft its author has not sent, visible only to whoever holds the
+                // token that wrote it. Reporting one as a review names a verdict
+                // nobody has read.
+                const submitted = landed.filter((r) => (r.state ?? "").toUpperCase() !== "PENDING");
+                // Reviews arrive oldest first, so a full page leaves the newest unread
+                // — and "has a review landed yet" is what this tool is called for. Said
+                // rather than left to the list, which would otherwise read as complete.
+                const moreReviews = landed.length >= GITHUB_PAGE_SIZE;
                 return bounded([
                     `#${number} ${data.title ?? "(no title)"}`,
                     `${data.merged ? "merged" : (data.state ?? "?")}` +
                         (data.draft ? " (draft)" : "") +
-                        // `mergeable` is computed asynchronously by GitHub and is `null`
-                        // until it has been, which is common on a pull request opened
-                        // seconds ago — exactly when this tool is most likely to be called.
-                        (data.mergeable === null
+                        // GitHub computes mergeability asynchronously and reports
+                        // `unknown` until it has, which is common on a pull request
+                        // opened seconds ago — exactly when this tool is most likely to
+                        // be called.
+                        (data.mergeable_state === undefined ||
+                            data.mergeable_state === "unknown"
                             ? ", mergeability not yet computed"
-                            : data.mergeable === false
-                                ? ", NOT mergeable"
-                                : ""),
+                            : data.mergeable_state === "clean"
+                                ? ""
+                                : `, mergeable_state ${data.mergeable_state}`),
                     `${data.head?.ref ?? "?"} → ${data.base?.ref ?? "?"}`,
                     data.html_url ?? "",
                     "",
+                    !reviews.ok
+                        ? "Reviews: (could not be read)"
+                        : submitted.length === 0
+                            ? "Reviews: none has landed yet."
+                            : [
+                                "Reviews:",
+                                ...submitted.map((r) => `  ${r.user?.login ?? "unknown"} — ${(r.state ?? "?").toLowerCase()}` +
+                                    `${r.submitted_at ? ` at ${r.submitted_at}` : ""}`)
+                            ].join("\n"),
+                    ...(moreReviews
+                        ? [
+                            `(showing the first ${GITHUB_PAGE_SIZE} reviews; this pull ` +
+                                `request has more, and the newest are not among them)`
+                        ]
+                        : []),
+                    "",
                     changed.length
                         ? changed
                             .map((f) => `  ${f.filename ?? "?"} (+${f.additions ?? 0} -${f.deletions ?? 0})`)
@@ -175,7 +240,7 @@ export function prActions(ctx) {
             description: "Leave a comment on a pull request or issue in the repository you have checked out. Use this to report what you did, or to answer a review — not to announce work you have not finished. The same comment twice in one task is posted once.",
             inputSchema: commentInput,
             timeoutMs: GITHUB_ACTION_TIMEOUT_MS,
-            idempotencyKey: async ({ input, ctx: turn }) => `${actionTask(turn)}:${input.dir}#${input.number}:comment:${await sha256(input.body)}`,
+            idempotencyKey: async ({ input, ctx: turn }) => `${actionTask(turn)}:${input.dir}#${input.number}:comment:${await sha256Hex(input.body)}`,
             execute: async ({ dir, number, body }) => {
                 const target = await githubRepo(dir);
                 if ("refusal" in target)

package/dist/{repo → repo-github}/tools-review.d.ts

@@ -8,5 +8,11 @@ export declare function reviewTools(ctx: RepoContext): ToolSet;
  * thrown. The one outcome returned short of success is a reply that landed on
  * a thread that did not resolve: that reply must never be sent again, so it is
  * settled, and the resolve-only call it asks for is a different key.
+ *
+ * **Still GraphQL, and still this plugin's own.** Replying and resolving have no
+ * REST equivalent, and the hosted MCP server offers them only under a tool that
+ * also submits reviews — `APPROVE` included — which is a grant nothing here
+ * wants. See `./mcp.ts`. Not installed on claude-coordinator, whose revising
+ * Claude Code sessions answer their own reviews from inside their containers.
  */
 export declare function reviewActions(ctx: RepoContext): Record<string, Action>;

package/dist/{repo → repo-github}/tools-review.js

@@ -1,8 +1,9 @@
 import { action } from "@cloudflare/think";
 import { tool } from "ai";
 import { z } from "zod";
-import { actionTask, GITHUB_ACTION_TIMEOUT_MS, GITHUB_PAGE_SIZE, sha256 } from "./context.js";
-/** A review as a conversation: whether it landed, what it said, and answering it. */
+import { sha256Hex } from "@dynamicagents/core";
+import { actionTask, GITHUB_ACTION_TIMEOUT_MS, GITHUB_PAGE_SIZE } from "./context.js";
+/** A review as a conversation: what it said, and answering it. */
 /**
  * How many pages of review threads one `repo_pr_threads` call will walk.
  *
@@ -20,59 +21,10 @@ const MAX_THREAD_PAGES = 10;
  *
  * Both ends, because the two uses pull opposite ways: what the reviewer asked for
  * is at the top, and whether a reply landed is at the bottom. A thread shorter
- * than this is returned whole and the two selections are the same comments, which
- * is why the render de-duplicates on the count rather than on the text.
+ * than this is returned whole, which is the ordinary case — the read asks for a
+ * hundred comments per thread and almost every thread has a handful.
  */
 const MAX_THREAD_COMMENTS = 6;
-/**
- * The review threads on one pull request.
- *
- * `isResolved` is the field the whole workflow turns on and REST does not expose
- * at all — which is why these three operations are GraphQL while everything else
- * in this file is REST. Both ends of each thread are selected; see
- * {@link MAX_THREAD_COMMENTS} for why one end is not enough.
- */
-const REVIEW_THREADS_QUERY = `
-  query($owner:String!,$repo:String!,$number:Int!,$after:String){
-    repository(owner:$owner,name:$repo){
-      pullRequest(number:$number){
-        reviewThreads(first:${GITHUB_PAGE_SIZE},after:$after){
-          pageInfo{hasNextPage endCursor}
-          nodes{
-            id isResolved isOutdated path line
-            opening: comments(first:1){nodes{author{login} body}}
-            latest: comments(last:${MAX_THREAD_COMMENTS}){totalCount nodes{author{login} body}}
-          }
-        }
-      }
-    }
-  }`;
-/**
- * Who is currently *asked* to review, apps included.
- *
- * REST's `pulls/{n}/requested_reviewers` carries `users` and `teams` and no
- * third key, so a Bot reviewer — Copilot is one — is absent from a request that
- * is live, and its answer for "Copilot is working on it right now" is byte for
- * byte its answer for "nobody was ever asked". GraphQL types the requested
- * reviewer as a union with `Bot` in it, which is what makes the two
- * distinguishable at all.
- */
-const REVIEW_REQUESTS_QUERY = `
-  query($owner:String!,$repo:String!,$number:Int!){
-    repository(owner:$owner,name:$repo){
-      pullRequest(number:$number){
-        reviewRequests(first:${GITHUB_PAGE_SIZE}){
-          nodes{
-            requestedReviewer{
-              ... on User{login}
-              ... on Bot{login}
-              ... on Team{slug}
-            }
-          }
-        }
-      }
-    }
-  }`;
 /** Which pull request, in which repository, a thread id names. */
 const THREAD_OWNER_QUERY = `
   query($id:ID!){
@@ -92,39 +44,59 @@ const THREAD_RESOLVE_MUTATION = `
   mutation($id:ID!){
     resolveReviewThread(input:{threadId:$id}){thread{isResolved}}
   }`;
-/** One thread, as the model reads it: where it is, its id, and the conversation. */
+/**
+ * One thread, as the model reads it: where it is, its id, and the conversation.
+ *
+ * Where it is comes from the **first comment** rather than the thread: a thread
+ * is a location only through the comments on it, so a thread whose comments did
+ * not come back has no file to name.
+ */
 function renderThread(t) {
-    const where = t.path
-        ? `${t.path}${typeof t.line === "number" ? `:${t.line}` : ""}`
+    const comments = t.comments ?? [];
+    const first = comments[0];
+    const line = first?.line ?? first?.original_line;
+    const where = first?.path
+        ? `${first.path}${typeof line === "number" ? `:${line}` : ""}`
         : "(no file)";
-    const total = t.latest?.totalCount ?? 0;
-    const tail = t.latest?.nodes ?? [];
+    const total = t.total_count ?? comments.length;
     // Whole when it fits, and both ends with the middle named when it does not.
     // The opening comment is the reviewer's actual point and the tail is where a
     // reply this plugin sent would be, so neither end can be the one dropped.
-    const conversation = total > tail.length
+    const shown = comments.length > MAX_THREAD_COMMENTS
         ? [
-            ...(t.opening?.nodes ?? []),
+            ...comments.slice(0, 1),
             {
-                author: { login: "…" },
-                body: `(${total - tail.length - 1} earlier replies not shown)`
+                author: "…",
+                body: `(${comments.length - MAX_THREAD_COMMENTS} earlier replies not shown)`
             },
-            ...tail
+            ...comments.slice(-(MAX_THREAD_COMMENTS - 1))
+        ]
+        : comments;
+    // Said only when the read itself was short of the conversation, which the
+    // slice above is not: that one is this render's own choice and both ends
+    // survive it.
+    const unread = total > comments.length
+        ? [
+            {
+                author: "…",
+                body: `(${total - comments.length} comments were not read)`
+            }
         ]
-        : tail;
+        : [];
     return [
-        `--- ${where}${t.isResolved ? " [resolved]" : ""}${t.isOutdated ? " [outdated]" : ""}`,
+        `--- ${where}${t.is_resolved ? " [resolved]" : ""}${t.is_outdated ? " [outdated]" : ""}`,
         `id: ${t.id}`,
-        ...conversation.map((c) => `${c.author?.login ?? "unknown"}: ${c.body ?? ""}`)
+        ...[...shown, ...unread].map((c) => `${c.author ?? "unknown"}: ${c.body ?? ""}`)
     ].join("\n");
 }
 /**
  * The owner and repository as their own names, rather than as REST path segments.
  *
  * {@link file://./context.ts githubRepo} percent-encodes both, because that is
- * what makes a path safe. A GraphQL *variable* is not a path — it is compared
- * against the repository's actual name — so an encoded one would silently stop
- * matching the moment a name contains a character worth encoding.
+ * what makes a path safe. A GraphQL *variable* and an MCP argument are not paths
+ * — both are compared against the repository's actual name — so an encoded one
+ * would silently stop matching the moment a name contains a character worth
+ * encoding.
  */
 function decoded(target) {
     return {
@@ -132,105 +104,11 @@ function decoded(target) {
         repo: decodeURIComponent(target.repo)
     };
 }
-/**
- * The review bot's logins, which GitHub does not spell the same way twice.
- *
- * One account arrives as `Copilot` from the issue timeline, as
- * `copilot-pull-request-reviewer` from GraphQL, and as
- * `copilot-pull-request-reviewer[bot]` from `pulls/{n}/reviews`. Compared
- * exactly against the login a caller names, the request matches and the review
- * never does, so `repo_pr_review_status` reports "none pending — waiting will
- * not change it" at the moment the review lands. That is the one answer a
- * polling caller stops on, so the mismatch does not degrade the tool, it
- * inverts it.
- *
- * An alternation of the spellings that account answers to, and deliberately not
- * a `copilot-` prefix: `copilot-swe-agent` is a **different** account, one that
- * opens pull requests rather than reviewing them, so a prefix would let its
- * request or its authorship answer a question asked about the reviewer.
- */
-const COPILOT_LOGIN = /^copilot(-pull-request-reviewer)?$/;
-/**
- * Whether a login from the API is the reviewer the caller asked about.
- *
- * `[bot]` is a suffix REST appends to an app's login and GraphQL does not, so it
- * is never part of the identity — stripping it is what lets a caller name any
- * app reviewer the way GitHub's UI shows it.
- */
-function sameReviewer(a, b) {
-    const bare = (login) => login.toLowerCase().replace(/\[bot\]$/, "");
-    const [x, y] = [bare(a), bare(b)];
-    return COPILOT_LOGIN.test(x) && COPILOT_LOGIN.test(y) ? true : x === y;
-}
 export function reviewTools(ctx) {
-    const { bounded, github, githubGraphql, githubRepo } = ctx;
+    const { bounded, mcp, githubRepo } = ctx;
     return {
-        repo_pr_review_status: tool({
-            description: "Say whether a reviewer has finished reviewing a pull request in the repository you have checked out. Use it before reading review comments: a review that has not landed has left no comments, and an empty thread list means nothing yet.",
-            inputSchema: z.object({
-                dir: z.string().describe("The checkout directory"),
-                number: z.number().int().positive().describe("Pull request number"),
-                reviewer: z
-                    .string()
-                    .optional()
-                    .describe('The reviewer to ask about, as their login. Defaults to "Copilot".')
-            }),
-            execute: async ({ dir, number, reviewer }) => {
-                const target = await githubRepo(dir);
-                if ("refusal" in target)
-                    return target.refusal;
-                const { owner, repo } = target;
-                const who = reviewer ?? "Copilot";
-                // A *pending* request outranks any review already on the pull request,
-                // and that ordering is the whole logic here. GitHub clears the request
-                // when a review is submitted and writes a new one when a re-review is
-                // asked for, so "still requested" is true now and "has reviewed" is
-                // about the past. Reading them the other way round reports a re-review
-                // as finished the moment it is asked for.
-                const requested = await githubGraphql("repo_pr_review_status", REVIEW_REQUESTS_QUERY, { owner, repo, number });
-                if (!requested.ok)
-                    return bounded(requested.message);
-                const waiting = requested.data.repository?.pullRequest?.reviewRequests;
-                if (!waiting)
-                    return `#${number} is not a pull request in ${owner}/${repo}`;
-                const pending = (waiting.nodes ?? []).some((n) => {
-                    const name = n?.requestedReviewer?.login ?? n?.requestedReviewer?.slug;
-                    return !!name && sameReviewer(name, who);
-                });
-                if (pending)
-                    return `${who} has been asked to review #${number} and has not finished.`;
-                const reviews = await github("repo_pr_review_status", `/repos/${owner}/${repo}/pulls/${number}/reviews?per_page=${GITHUB_PAGE_SIZE}`);
-                if (!reviews.ok)
-                    return bounded(reviews.message);
-                const all = reviews.data;
-                const submitted = all.filter((r) => !!r.user?.login &&
-                    sameReviewer(r.user.login, who) &&
-                    // A `PENDING` review is a draft its author has not sent, and it is
-                    // visible to whoever holds the token that wrote it. Counting one as
-                    // finished reports a review nobody has read, which is the answer a
-                    // poll loop acts on by stopping.
-                    (r.state ?? "").toUpperCase() !== "PENDING");
-                const theirs = submitted.at(-1);
-                if (!theirs) {
-                    // The endpoint pages oldest-first, so a match beyond the first page is
-                    // **newer** than everything read — which is to say it is exactly the
-                    // review being waited for. So a truncated read cannot answer the
-                    // question at all, and must not answer it with "waiting will not help":
-                    // that is the one reply a caller ends its polling on.
-                    if (all.length >= GITHUB_PAGE_SIZE)
-                        return bounded(`#${number} has at least ${GITHUB_PAGE_SIZE} reviews and only the oldest were read, ` +
-                            `so whether ${who} has reviewed it is unknown. Read the pull request itself with repo_pr_view, ` +
-                            `or look for threads with repo_pr_threads.`);
-                    return bounded(`#${number} has no review from ${who}, and none is pending. ` +
-                        `Nobody asked them, or the request was withdrawn — waiting will not change it.`);
-                }
-                return bounded(`${who} reviewed #${number}${theirs.submitted_at ? ` at ${theirs.submitted_at}` : ""}` +
-                    `${theirs.state ? ` (${theirs.state.toLowerCase()})` : ""}. ` +
-                    `Read what it said with repo_pr_threads — a review can finish having left no comments.`);
-            }
-        }),
         repo_pr_threads: tool({
-            description: "Read the review threads on a pull request in the repository you have checked out — the inline comments a reviewer left on specific lines, which are not on the conversation timeline repo_issue_view reads. Unresolved ones only, unless you ask for all.",
+            description: "Read the review threads on a pull request in the repository you have checked out — the inline comments a reviewer left on specific lines, which are not on the conversation timeline repo_issue_view reads. Unresolved ones only, unless you ask for all. An empty answer on a pull request whose review has not landed means nothing yet rather than nothing to do — repo_pr_view says whether one has.",
             inputSchema: z.object({
                 dir: z.string().describe("The checkout directory"),
                 number: z.number().int().positive().describe("Pull request number"),
@@ -245,7 +123,7 @@ export function reviewTools(ctx) {
                     return target.refusal;
                 const { owner, repo } = decoded(target);
                 const threads = [];
-                let after = null;
+                let after;
                 let truncated = false;
                 // Paged, and that is not an optimisation. A review long enough to spill a
                 // page puts its newest threads on the last one — exactly the threads the
@@ -257,21 +135,23 @@ export function reviewTools(ctx) {
                         truncated = true;
                         break;
                     }
-                    const answered = await githubGraphql("repo_pr_threads", REVIEW_THREADS_QUERY, {
+                    const answered = await mcp("repo_pr_threads", "pull_request_read", {
                         owner,
                         repo,
-                        number,
-                        after
+                        pullNumber: number,
+                        method: "get_review_comments",
+                        perPage: GITHUB_PAGE_SIZE,
+                        ...(after ? { after } : {})
                     });
                     if (!answered.ok)
                         return bounded(answered.message);
-                    const page_ = answered.data.repository?.pullRequest?.reviewThreads;
-                    if (!page_)
+                    const page_ = answered.data;
+                    if (!page_?.review_threads)
                         return `#${number} is not a pull request in ${owner}/${repo}`;
-                    threads.push(...(page_.nodes ?? []));
-                    if (!page_.pageInfo?.hasNextPage)
+                    threads.push(...page_.review_threads);
+                    if (!page_.page_info?.has_next_page)
                         break;
-                    after = page_.pageInfo.endCursor ?? null;
+                    after = page_.page_info.end_cursor ?? undefined;
                     if (!after)
                         break;
                 }
@@ -285,7 +165,7 @@ export function reviewTools(ctx) {
                     : "";
                 const shown = includeResolved
                     ? threads
-                    : threads.filter((t) => !t.isResolved);
+                    : threads.filter((t) => !t.is_resolved);
                 if (shown.length === 0)
                     return bounded((includeResolved
                         ? `#${number} has no review threads.`
@@ -305,6 +185,12 @@ export function reviewTools(ctx) {
  * thrown. The one outcome returned short of success is a reply that landed on
  * a thread that did not resolve: that reply must never be sent again, so it is
  * settled, and the resolve-only call it asks for is a different key.
+ *
+ * **Still GraphQL, and still this plugin's own.** Replying and resolving have no
+ * REST equivalent, and the hosted MCP server offers them only under a tool that
+ * also submits reviews — `APPROVE` included — which is a grant nothing here
+ * wants. See `./mcp.ts`. Not installed on claude-coordinator, whose revising
+ * Claude Code sessions answer their own reviews from inside their containers.
  */
 export function reviewActions(ctx) {
     const { bounded, githubGraphql, githubRepo } = ctx;
@@ -332,7 +218,7 @@ export function reviewActions(ctx) {
             // The thread and the resolve flag as well as the body, or the same reply
             // to two threads — "Fixed." — would be one key.
             idempotencyKey: async ({ input, ctx: turn }) => `${actionTask(turn)}:${input.dir}#${input.number}:${input.threadId}:` +
-                `${await sha256(input.body ?? "")}:${input.resolve ?? true}`,
+                `${await sha256Hex(input.body ?? "")}:${input.resolve ?? true}`,
             execute: async ({ dir, number, threadId, body, resolve }) => {
                 const target = await githubRepo(dir);
                 if ("refusal" in target)

package/dist/{repo → repo-github}/url.d.ts

@@ -6,6 +6,17 @@
  * naming it": every pattern here turns away a string that resolves to something
  * other than what it appears to name.
  */
+/**
+ * The one host whose API these tools talk to.
+ *
+ * Narrower than {@link DEFAULT_ALLOWED_HOSTS}, which a host may widen: cloning
+ * is generic git and works anywhere, while every API read goes to github.com's
+ * hosted MCP server and every write to github.com's REST and GraphQL. So a
+ * checkout on another allowed host has an origin these tools must refuse rather
+ * than resolve — see `githubRepo` in `./context.ts`, which is where that is
+ * enforced.
+ */
+export declare const GITHUB_HOST = "github.com";
 /** The hosts a clone URL may name. `RepoConfig.allowedHosts` overrides it. */
 export declare const DEFAULT_ALLOWED_HOSTS: string[];
 /** Branch names a push must never target, whatever the model believes. */

package/dist/{repo → repo-github}/url.js

@@ -6,8 +6,19 @@
  * naming it": every pattern here turns away a string that resolves to something
  * other than what it appears to name.
  */
+/**
+ * The one host whose API these tools talk to.
+ *
+ * Narrower than {@link DEFAULT_ALLOWED_HOSTS}, which a host may widen: cloning
+ * is generic git and works anywhere, while every API read goes to github.com's
+ * hosted MCP server and every write to github.com's REST and GraphQL. So a
+ * checkout on another allowed host has an origin these tools must refuse rather
+ * than resolve — see `githubRepo` in `./context.ts`, which is where that is
+ * enforced.
+ */
+export const GITHUB_HOST = "github.com";
 /** The hosts a clone URL may name. `RepoConfig.allowedHosts` overrides it. */
-export const DEFAULT_ALLOWED_HOSTS = ["github.com"];
+export const DEFAULT_ALLOWED_HOSTS = [GITHUB_HOST];
 /** Branch names a push must never target, whatever the model believes. */
 export const PROTECTED_BRANCHES = new Set([
     "main",