@makerx/yoke 0.16.0 → 0.17.0

package/dist/cli.js

@@ -7,7 +7,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@makerx/yoke",
-  version: "0.16.0",
+  version: "0.17.0",
   description: "Lean, user-invoked Claude Code skills for MakerX AI-assisted delivery, plus the CLI they call.",
   license: "MIT",
   author: "MakerX",
@@ -432,50 +432,6 @@ function raisePr({ title, body, base, draft }, run2 = runGh) {
   return output.at(-1) ?? "";
 }
 
-// src/features/review/ci.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
-
-// src/features/review/shellQuote.ts
-function shellQuote(value) {
-  return `'${value.replaceAll("'", `'\\''`)}'`;
-}
-
-// src/features/review/ciEntra.ts
-var githubOidcIssuer = "https://token.actions.githubusercontent.com";
-var entraTokenExchangeAudience = "api://AzureADTokenExchange";
-function federatedCredential(repo, environment) {
-  return {
-    issuer: githubOidcIssuer,
-    audience: entraTokenExchangeAudience,
-    subject: environment ? `repo:${repo}:environment:${environment}` : `repo:${repo}:pull_request`
-  };
-}
-function federatedCredentialCommand(clientId, credential) {
-  const parameters = JSON.stringify({
-    name: "yoke-review-ci",
-    issuer: credential.issuer,
-    subject: credential.subject,
-    audiences: [credential.audience]
-  });
-  return `az ad app federated-credential create --id ${shellQuote(clientId)} --parameters ${shellQuote(parameters)}`;
-}
-function entraSetup({ clientId, environment }, repo) {
-  const credential = federatedCredential(repo, environment);
-  return [
-    "",
-    `Instead of an API key, the review signs in to Foundry as Entra app ${clientId}. So that the app trusts this repo's review runs, add a federated credential to it with:`,
-    `  issuer:   ${credential.issuer}`,
-    `  audience: ${credential.audience}`,
-    `  subject:  ${credential.subject}`,
-    "for example with:",
-    `  ${federatedCredentialCommand(clientId, credential)}`,
-    "and give the app the Cognitive Services User role on the Foundry resource.",
-    ...environment ? [`The job runs in the ${environment} environment; create it on the repo if it does not exist.`] : []
-  ];
-}
-
 // src/features/review/pr.ts
 import { execFile } from "child_process";
 import { join as join2 } from "path";
@@ -538,19 +494,19 @@ function isPendingReview(value) {
 }
 async function openPendingReview(pr2, exec2 = run) {
   const args = ["api", "--method", "POST", reviewsPath(pr2), "--input", "-", "--jq", "{id, node_id}"];
-  const review = JSON.parse(await exec2("gh", args, void 0, JSON.stringify({ commit_id: pr2.headRefOid })));
-  if (!isPendingReview(review)) throw new ReviewError("Opening a pending review returned an unexpected response");
-  return { id: review.id, nodeId: review.node_id };
+  const review2 = JSON.parse(await exec2("gh", args, void 0, JSON.stringify({ commit_id: pr2.headRefOid })));
+  if (!isPendingReview(review2)) throw new ReviewError("Opening a pending review returned an unexpected response");
+  return { id: review2.id, nodeId: review2.node_id };
 }
 var addThread = `mutation($review: ID!, $path: String!, $line: Int!, $body: String!) {
   addPullRequestReviewThread(input: {pullRequestReviewId: $review, path: $path, line: $line, side: RIGHT, body: $body}) { thread { id } }
 }`;
-async function addReviewComment(review, { path, line, body }, exec2 = run) {
+async function addReviewComment(review2, { path, line, body }, exec2 = run) {
   const variables = [
     "-f",
     `query=${addThread}`,
     "-f",
-    `review=${review.nodeId}`,
+    `review=${review2.nodeId}`,
     "-f",
     `path=${path}`,
     "-F",
@@ -560,24 +516,28 @@ async function addReviewComment(review, { path, line, body }, exec2 = run) {
   ];
   await exec2("gh", ["api", "graphql", ...variables]);
 }
-async function submitPendingReview(pr2, review, body, exec2 = run) {
-  const args = ["api", "--method", "POST", `${reviewsPath(pr2)}/${review.id}/events`, "--input", "-", "--jq", ".html_url"];
+async function submitPendingReview(pr2, review2, body, exec2 = run) {
+  const args = ["api", "--method", "POST", `${reviewsPath(pr2)}/${review2.id}/events`, "--input", "-", "--jq", ".html_url"];
   return (await exec2("gh", args, void 0, JSON.stringify({ event: "COMMENT", body }))).trim();
 }
-async function discardPendingReview(pr2, review, exec2 = run) {
-  await exec2("gh", ["api", "--method", "DELETE", `${reviewsPath(pr2)}/${review.id}`]);
+async function discardPendingReview(pr2, review2, exec2 = run) {
+  await exec2("gh", ["api", "--method", "DELETE", `${reviewsPath(pr2)}/${review2.id}`]);
 }
 async function githubGet(path, exec2 = run) {
   return JSON.parse(await exec2("gh", ["api", path]));
 }
 async function githubPost(path, body, exec2 = run) {
-  return JSON.parse(await exec2("gh", ["api", "--method", "POST", path, "--input", "-"], void 0, JSON.stringify(body)));
+  const output = await exec2("gh", ["api", "--method", "POST", path, "--input", "-"], void 0, JSON.stringify(body));
+  return output.trim() ? JSON.parse(output) : null;
+}
+async function githubDelete(path, exec2 = run) {
+  await exec2("gh", ["api", "--method", "DELETE", path]);
 }
 var github = {
   open: (pr2) => openPendingReview(pr2),
-  add: (review, comment) => addReviewComment(review, comment),
-  submit: (pr2, review, body) => submitPendingReview(pr2, review, body),
-  discard: (pr2, review) => discardPendingReview(pr2, review)
+  add: (review2, comment) => addReviewComment(review2, comment),
+  submit: (pr2, review2, body) => submitPendingReview(pr2, review2, body),
+  discard: (pr2, review2) => discardPendingReview(pr2, review2)
 };
 function repoSlug(remoteUrl) {
   return remoteUrl.replace(/\.git$/, "").split(/[/:]/).slice(-2).join("/").toLowerCase();
@@ -691,12 +651,57 @@ function buildOverride({ harness, model }, provider) {
   return buildClaudeOverride(provider, endpoints, model);
 }
 
+// src/features/review/ci.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+
+// src/features/review/shellQuote.ts
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+// src/features/review/ciEntra.ts
+var githubOidcIssuer = "https://token.actions.githubusercontent.com";
+var entraTokenExchangeAudience = "api://AzureADTokenExchange";
+function federatedCredential(repo, environment) {
+  return {
+    issuer: githubOidcIssuer,
+    audience: entraTokenExchangeAudience,
+    subject: environment ? `repo:${repo}:environment:${environment}` : `repo:${repo}:pull_request`
+  };
+}
+function federatedCredentialCommand(clientId, credential) {
+  const parameters = JSON.stringify({
+    name: "yoke-review-ci",
+    issuer: credential.issuer,
+    subject: credential.subject,
+    audiences: [credential.audience]
+  });
+  return `az ad app federated-credential create --id ${shellQuote(clientId)} --parameters ${shellQuote(parameters)}`;
+}
+function entraSetup({ clientId, environment }, repo) {
+  const credential = federatedCredential(repo, environment);
+  return [
+    "",
+    `Instead of an API key, the review signs in to Foundry as Entra app ${clientId}. So that the app trusts this repo's review runs, add a federated credential to it with:`,
+    `  issuer:   ${credential.issuer}`,
+    `  audience: ${credential.audience}`,
+    `  subject:  ${credential.subject}`,
+    "for example with:",
+    `  ${federatedCredentialCommand(clientId, credential)}`,
+    "and give the app the Cognitive Services User role on the Foundry resource.",
+    ...environment ? [`The job runs in the ${environment} environment; create it on the repo if it does not exist.`] : []
+  ];
+}
+
 // src/features/review/ci.ts
 var reviewWorkflowRef = "MakerXStudio/yoke/.github/workflows/review.yml@main";
 var callerWorkflowPath = join3(".github", "workflows", "review-pr.yml");
 var baseUrlVariable = "REVIEW_CI_BASE_URL";
 var apiKeySecret = "REVIEW_CI_API_KEY";
 var callerTriggerTypes = ["opened", "synchronize", "reopened", "ready_for_review"];
+var callerTargetTypes = ["labeled", "synchronize"];
 var gateCheck = "review / gate";
 function workflowSecrets({ entra }) {
   return entra ? [] : [apiKeySecret];
@@ -762,11 +767,14 @@ function renderCallerWorkflow(workflow) {
     "on:",
     "  pull_request:",
     `    types: [${callerTriggerTypes.join(", ")}]`,
+    "  pull_request_target:",
+    `    types: [${callerTargetTypes.join(", ")}]`,
     "",
     "permissions:",
-    "  actions: read",
+    "  actions: write",
     "  contents: read",
     "  pull-requests: write",
+    "  statuses: write",
     ...workflow.entra ? ["  id-token: write"] : [],
     "",
     "jobs:",
@@ -802,12 +810,12 @@ function repoRoot(cwd = process.cwd()) {
   try {
     return execFileSync2("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
   } catch {
-    throw new ReviewError("Not in a git repository; run `yoke review-ci` from the repo to review.");
+    throw new ReviewError("Not in a git repository; run `yoke review ci` from the repo to review.");
   }
 }
 var editInPlaceMessage = [
   `${callerWorkflowPath} already exists and differs from yoke's version, so it was left as it is.`,
-  "Edit it in place to run yoke's review, keeping its provider, models and names. `yoke review-ci --print` shows yoke's version without saving it."
+  "Edit it in place to run yoke's review, keeping its provider, models and names. `yoke review ci --print` shows yoke's version without saving it."
 ].join("\n");
 function writeCallerWorkflow(root, content) {
   const path = join3(root, callerWorkflowPath);
@@ -846,369 +854,77 @@ function reviewCiReport(outcome, settings, workflow, repo) {
   ].join("\n");
 }
 
-// src/features/review/ciGate.ts
-import { z as z3 } from "zod";
-
-// src/features/review/ciGateCaller.ts
-import { parse } from "yaml";
-import { z as z2 } from "zod";
-var yokeRepo = "MakerXStudio/yoke";
-var localReviewWorkflow = "./.github/workflows/review.yml";
-var reviewWorkflowPrefix = reviewWorkflowRef.slice(0, reviewWorkflowRef.indexOf("@") + 1).toLowerCase();
-var workflowSchema = z2.looseObject({
-  on: z2.unknown().optional(),
-  permissions: z2.unknown().optional(),
-  jobs: z2.record(z2.string(), z2.looseObject({ uses: z2.unknown().optional(), permissions: z2.unknown().optional() }).nullable()).optional()
-});
-function parseWorkflow(content) {
-  try {
-    const result = workflowSchema.safeParse(parse(content));
-    return result.success ? result.data : void 0;
-  } catch {
-    return void 0;
-  }
+// src/features/review/comments.ts
+var markerPrefix = "<!-- yoke-review:";
+function slug(text2) {
+  return text2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
-function callsReview(uses, repo) {
-  if (typeof uses !== "string") return false;
-  if (uses.toLowerCase().startsWith(reviewWorkflowPrefix)) return true;
-  return repo.toLowerCase() === yokeRepo.toLowerCase() && uses === localReviewWorkflow;
+function findingMarker({ file, title }) {
+  return `${markerPrefix} ${file ?? "n/a"}#${slug(title)} -->`;
 }
-function listIncludes(value, item) {
-  return value === item || Array.isArray(value) && value.includes(item);
+function hasMarker(prior, marker) {
+  return prior.some((comment) => comment.body.includes(marker));
 }
-function pullRequestTrigger(on) {
-  if (typeof on !== "object" || on === null || Array.isArray(on) || !("pull_request" in on)) return void 0;
-  const trigger = on.pull_request;
-  return typeof trigger === "object" && trigger !== null && !Array.isArray(trigger) ? { ...trigger } : void 0;
+function withoutMarkers(body) {
+  return body.split("\n").filter((line) => !line.trimStart().startsWith(markerPrefix)).join("\n").trim();
 }
-function runsOnSynchronize(on) {
-  if (typeof on === "string" || Array.isArray(on)) return listIncludes(on, "pull_request");
-  if (typeof on !== "object" || on === null || !("pull_request" in on)) return false;
-  const trigger = pullRequestTrigger(on);
-  if (!trigger || !("types" in trigger)) return true;
-  return listIncludes(trigger.types, "synchronize");
+function heading({ path, line }) {
+  if (!path) return "### PR review";
+  return line === null ? `### ${path}` : `### ${path}:${line}`;
 }
-function globMatches(pattern, branch) {
-  const source = pattern.split(/(\*\*|\*|\?)/).map((part) => ({ "**": ".*", "*": "[^/]*", "?": "." })[part] ?? part.replace(/[.+^${}()|[\]\\]/g, "\\$&")).join("");
-  return new RegExp(`^${source}$`).test(branch);
+function formatPriorComments(prior) {
+  if (!prior.length) return "";
+  const blocks = prior.map((comment) => `${heading(comment)}
+
+**${comment.author}**: ${withoutMarkers(comment.body)}`);
+  return `## Prior review comments
+
+The PR already has the review comments below, including resolved and outdated threads. Do not re-raise a finding a prior comment substantively covers.
+
+${blocks.join("\n\n")}
+`;
 }
-function patterns(value) {
-  if (typeof value === "string") return [value];
-  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+
+// src/features/review/findings.ts
+var severities = ["blocker", "major", "minor", "nit"];
+var sources = ["confirmed", "disputed", "reviewer1-only", "reviewer2-only", "already-raised"];
+function oneOf(values, raw) {
+  const value = raw.toLowerCase();
+  return values.find((v) => v === value) ?? null;
 }
-function branchesInclude(value, branch) {
-  return patterns(value).reduce(
-    (included, pattern) => pattern.startsWith("!") ? included && !globMatches(pattern.slice(1), branch) : included || globMatches(pattern, branch),
-    false
-  );
+function field(block, name) {
+  return block.match(new RegExp(`^-\\s+${name}:\\s*(.*)$`, "im"))?.[1]?.trim() ?? "";
 }
-function skipFilters(on, branch) {
-  const trigger = pullRequestTrigger(on);
-  if (!trigger) return [];
-  const filters = ["paths", "paths-ignore"].filter((key) => key in trigger);
-  if ("branches" in trigger && !branchesInclude(trigger.branches, branch)) filters.push("branches");
-  if ("branches-ignore" in trigger && patterns(trigger["branches-ignore"]).some((pattern) => globMatches(pattern, branch)))
-    filters.push("branches-ignore");
-  return filters;
+function parseLocation(raw) {
+  const location = raw.replace(/^`+|`+$/g, "").trim();
+  if (!location || location.toLowerCase() === "n/a") return { file: null, line: null };
+  const match = location.match(/^(.+?):(\d+)(?:-\d+)?$/);
+  if (!match?.[1] || !match[2]) return { file: location, line: null };
+  return { file: match[1], line: Number(match[2]) };
 }
-function canReadActions(permissions) {
-  if (permissions === "read-all" || permissions === "write-all") return true;
-  if (typeof permissions !== "object" || permissions === null || !("actions" in permissions)) return false;
-  return permissions.actions === "read" || permissions.actions === "write";
+function parseFinding(block) {
+  const [heading2 = "", ...rest] = block.split("\n");
+  const body = rest.join("\n");
+  return {
+    title: heading2.trim(),
+    severity: oneOf(severities, field(body, "Severity")),
+    source: oneOf(sources, field(body, "Source")),
+    ...parseLocation(field(body, "Location")),
+    impact: field(body, "Impact"),
+    recommendation: field(body, "Recommendation")
+  };
 }
-function checkWorkflow(path, workflow, repo, branch) {
-  const jobs = Object.values(workflow.jobs ?? {}).filter((job) => job && callsReview(job.uses, repo));
-  if (jobs.length === 0) return void 0;
-  const problems2 = [];
-  if (!runsOnSynchronize(workflow.on)) problems2.push("lacks the `synchronize` type in its `pull_request` trigger");
-  if (!jobs.some((job) => canReadActions(job?.permissions ?? workflow.permissions)))
-    problems2.push("lacks `actions: read` in its permissions");
-  const filters = skipFilters(workflow.on, branch);
-  if (filters.length > 0)
-    problems2.push(
-      `skips some PRs to ${branch} through its \`pull_request\` ${filters.map((filter) => `\`${filter}\``).join(", ")} filter${filters.length > 1 ? "s" : ""}, so those PRs could never merge`
-    );
-  return { path, problems: problems2 };
+function parseSummary(markdown) {
+  return markdown.match(/^##\s+Summary\s*$([\s\S]*?)(?=^##\s|(?![\s\S]))/m)?.[1]?.trim() ?? "";
 }
-function checkCallerWorkflows(files, repo, branch) {
-  const callers = files.flatMap(({ path, content }) => {
-    const workflow = parseWorkflow(content);
-    const check = workflow && checkWorkflow(path, workflow, repo, branch);
-    return check ? [check] : [];
-  });
-  return callers.find((caller) => caller.problems.length === 0) ?? callers[0];
+function rank(finding) {
+  const severity = finding.severity ? severities.indexOf(finding.severity) : severities.length;
+  const source = finding.source ? sources.indexOf(finding.source) : sources.length;
+  return severity * (sources.length + 1) + source;
 }
-
-// src/features/review/ciGate.ts
-var gateRuleset = {
-  name: "yoke review",
-  target: "branch",
-  enforcement: "active",
-  conditions: { ref_name: { include: ["~DEFAULT_BRANCH"], exclude: [] } },
-  rules: [
-    {
-      type: "required_status_checks",
-      parameters: { strict_required_status_checks_policy: false, required_status_checks: [{ context: gateCheck }] }
-    }
-  ]
-};
-var recentPrCount = 20;
-var repoSchema = z3.object({
-  full_name: z3.string(),
-  html_url: z3.string(),
-  default_branch: z3.string()
-});
-var branchRulesSchema = z3.array(
-  z3.object({
-    type: z3.string(),
-    ruleset_id: z3.number().optional(),
-    parameters: z3.object({ required_status_checks: z3.array(z3.object({ context: z3.string() })).optional() }).optional()
-  })
-);
-var directorySchema = z3.array(z3.object({ type: z3.string(), name: z3.string(), path: z3.string() }));
-var fileSchema = z3.object({ content: z3.string() });
-var pullsSchema = z3.array(z3.object({ head: z3.object({ sha: z3.string() }) }));
-var checkRunsSchema = z3.object({ total_count: z3.number() });
-var createdSchema = z3.object({ id: z3.number() });
-var rulesetsSchema = z3.array(z3.object({ id: z3.number(), name: z3.string(), enforcement: z3.string() }));
-var githubApi = { get: (path) => githubGet(path), post: (path, body) => githubPost(path, body) };
-async function getUnlessMissing(api, path) {
-  try {
-    return await api.get(path);
-  } catch (error) {
-    if (error instanceof ReviewError && error.message.includes("(HTTP 404)")) return void 0;
-    throw error;
-  }
-}
-async function workflowFiles(api, repo) {
-  const ref = `ref=${encodeURIComponent(repo.default_branch)}`;
-  const listing = await getUnlessMissing(api, `repos/${repo.full_name}/contents/.github/workflows?${ref}`);
-  if (listing === void 0) return [];
-  const files = directorySchema.parse(listing).filter((entry) => entry.type === "file" && /\.ya?ml$/.test(entry.name));
-  return Promise.all(
-    files.map(async ({ path }) => {
-      const { content } = fileSchema.parse(await api.get(`repos/${repo.full_name}/contents/${path}?${ref}`));
-      return { path, content: Buffer.from(content, "base64").toString("utf8") };
-    })
-  );
-}
-async function callerProblem(api, repo) {
-  const branch = repo.default_branch;
-  const caller = checkCallerWorkflows(await workflowFiles(api, repo), repo.full_name, branch);
-  if (!caller) return `No workflow on ${branch} calls yoke's review.yml. Run /review-ci, then merge its ${callerWorkflowPath} to ${branch}.`;
-  if (caller.problems.length > 0)
-    return `${caller.path} on ${branch} calls yoke's review.yml but ${caller.problems.join(" and ")}. Fix it and merge the change to ${branch}.`;
-  return void 0;
-}
-async function gateHasReported(api, repo) {
-  const pulls = pullsSchema.parse(
-    await api.get(`repos/${repo.full_name}/pulls?state=all&sort=updated&direction=desc&per_page=${recentPrCount}`)
-  );
-  for (const { head } of pulls) {
-    const runs = checkRunsSchema.parse(
-      await api.get(`repos/${repo.full_name}/commits/${head.sha}/check-runs?check_name=${encodeURIComponent(gateCheck)}&per_page=1`)
-    );
-    if (runs.total_count > 0) return true;
-  }
-  return false;
-}
-async function rulesetProblem(api, repo) {
-  const rulesets = rulesetsSchema.parse(await api.get(`repos/${repo.full_name}/rulesets?includes_parents=false&per_page=100`));
-  const existing = rulesets.find((ruleset) => ruleset.name === gateRuleset.name);
-  if (!existing) return void 0;
-  return `The "${gateRuleset.name}" ruleset already exists with enforcement \`${existing.enforcement}\` but doesn't require ${gateCheck} on ${repo.default_branch}: ${repo.html_url}/rules/${existing.id}. Set its enforcement to Active and its required check to ${gateCheck}, or delete it and run this again.`;
-}
-async function createRuleset(api, repo) {
-  try {
-    return await api.post(`repos/${repo.full_name}/rulesets`, gateRuleset);
-  } catch (error) {
-    if (error instanceof ReviewError && /\(HTTP 40[34]\)/.test(error.message))
-      throw new ReviewError(
-        `GitHub refused to add the "${gateRuleset.name}" ruleset to ${repo.full_name}: your gh user can't edit its repository rules. Ask a repo admin, or someone whose role can edit repository rules, to run \`yoke review-ci-gate\`.`
-      );
-    throw error;
-  }
-}
-async function problems(api, repo) {
-  const found = [];
-  const ruleset = await rulesetProblem(api, repo);
-  if (ruleset) found.push(ruleset);
-  const caller = await callerProblem(api, repo);
-  if (caller) found.push(caller);
-  if (!await gateHasReported(api, repo))
-    found.push(
-      `No ${gateCheck} check run on the ${recentPrCount} most recently updated PRs. Open or push to a PR so the gate reports, then run this again.`
-    );
-  return found;
-}
-async function enforceReviewGate(api = githubApi) {
-  const repo = repoSchema.parse(await api.get("repos/{owner}/{repo}"));
-  const branch = repo.default_branch;
-  const rules = branchRulesSchema.parse(await api.get(`repos/${repo.full_name}/rules/branches/${encodeURIComponent(branch)}`));
-  const existing = rules.find(
-    (rule) => rule.type === "required_status_checks" && rule.parameters?.required_status_checks?.some((check) => check.context === gateCheck)
-  );
-  if (existing) {
-    const where = existing.ruleset_id ? ` by ${repo.html_url}/rules/${existing.ruleset_id}` : "";
-    return { created: false, message: `${gateCheck} is already required on ${branch}${where}; nothing changed.` };
-  }
-  const found = await problems(api, repo);
-  if (found.length > 0)
-    throw new ReviewError([`Cannot require ${gateCheck} on ${branch} yet:`, ...found.map((problem) => `- ${problem}`)].join("\n"));
-  const { id } = createdSchema.parse(await createRuleset(api, repo));
-  return {
-    created: true,
-    message: `Added the "${gateRuleset.name}" ruleset, which blocks merging to ${branch} until ${gateCheck} passes: ${repo.html_url}/rules/${id}`
-  };
-}
-
-// src/features/review/gate.ts
-import { appendFileSync, readFileSync as readFileSync3 } from "fs";
-import { setTimeout } from "timers/promises";
-import { z as z4 } from "zod";
-var eventSchema = z4.object({
-  action: z4.string(),
-  pull_request: z4.object({
-    number: z4.number(),
-    head: z4.object({ ref: z4.string(), repo: z4.object({ full_name: z4.string() }).nullable() }),
-    user: z4.object({ type: z4.string() })
-  })
-});
-var runsSchema = z4.object({
-  workflow_runs: z4.array(z4.object({ id: z4.number(), run_number: z4.number(), pull_requests: z4.array(z4.object({ number: z4.number() })) }))
-});
-var jobsSchema = z4.object({ jobs: z4.array(z4.object({ name: z4.string(), status: z4.string(), conclusion: z4.string().nullable() })) });
-var pollInterval = 3e4;
-var rerunHint = "Mark the PR as draft, then ready for review, to run the review again.";
-var firstRunHint = "Mark the PR as ready for review (from draft if it is not one) to run it.";
-function verdict(conclusion, message) {
-  const pass = conclusion === "success";
-  return { pass, message: pass ? message : `${message} ${rerunHint}` };
-}
-function gateContext(env = process.env) {
-  const { GITHUB_REPOSITORY, GITHUB_RUN_ID, GITHUB_RUN_NUMBER, GITHUB_SERVER_URL, GITHUB_EVENT_PATH } = env;
-  if (!GITHUB_REPOSITORY || !GITHUB_RUN_ID || !GITHUB_RUN_NUMBER || !GITHUB_SERVER_URL || !GITHUB_EVENT_PATH) {
-    throw new ReviewError("yoke review-gate runs only in a GitHub Actions pull_request workflow");
-  }
-  const event = eventSchema.safeParse(JSON.parse(readFileSync3(GITHUB_EVENT_PATH, "utf8")));
-  if (!event.success) throw new ReviewError("yoke review-gate runs only on pull_request events");
-  return {
-    repo: GITHUB_REPOSITORY,
-    runId: GITHUB_RUN_ID,
-    runNumber: Number(GITHUB_RUN_NUMBER),
-    serverUrl: GITHUB_SERVER_URL,
-    event: event.data
-  };
-}
-async function earlierRuns({ repo, runId, runNumber, event }, deps) {
-  const { workflow_id } = z4.object({ workflow_id: z4.number() }).parse(await deps.get(`repos/${repo}/actions/runs/${runId}`));
-  const query = new URLSearchParams({ event: "pull_request", branch: event.pull_request.head.ref, per_page: "100" });
-  const { workflow_runs } = runsSchema.parse(await deps.get(`repos/${repo}/actions/workflows/${workflow_id}/runs?${query.toString()}`));
-  return workflow_runs.filter((run2) => run2.run_number < runNumber && run2.pull_requests.some((pr2) => pr2.number === event.pull_request.number)).toSorted((a, b) => b.run_number - a.run_number).map((run2) => run2.id);
-}
-async function settledReview(repo, run2, deps) {
-  for (; ; ) {
-    const { jobs } = jobsSchema.parse(await deps.get(`repos/${repo}/actions/runs/${run2}/jobs`));
-    const review = jobs.find((job) => job.name.endsWith(" / review"));
-    if (!review || review.conclusion === "skipped") return void 0;
-    if (review.status === "completed") return review.conclusion ?? "unknown";
-    deps.log(`Waiting for the review in run ${run2} to finish (${review.status})`);
-    await deps.sleep(pollInterval);
-  }
-}
-async function reviewGate(reviewResult, context, deps) {
-  if (reviewResult !== "skipped") return verdict(reviewResult, `The review on this event finished with ${reviewResult}.`);
-  const { pull_request } = context.event;
-  if (pull_request.head.repo?.full_name !== context.repo || pull_request.user.type === "Bot") {
-    return verdict("success", "No review runs for PRs from forks or bots.");
-  }
-  for (const run2 of await earlierRuns(context, deps)) {
-    const conclusion = await settledReview(context.repo, run2, deps);
-    const url = `${context.serverUrl}/${context.repo}/actions/runs/${run2}`;
-    if (conclusion) return verdict(conclusion, `The latest review for this PR, in run ${url}, finished with ${conclusion}.`);
-  }
-  return { pass: false, message: `No review has completed for this PR yet. ${firstRunHint}` };
-}
-async function runReviewGate(reviewResult, out, env = process.env) {
-  const deps = { get: (path) => githubGet(path), sleep: (ms) => setTimeout(ms), log: out };
-  const { pass, message } = await reviewGate(reviewResult, gateContext(env), deps);
-  out(pass ? message : `::error::${message}`);
-  if (env.GITHUB_STEP_SUMMARY) appendFileSync(env.GITHUB_STEP_SUMMARY, `${message}
-`);
-  return pass;
-}
-
-// src/features/review/comments.ts
-var markerPrefix = "<!-- yoke-review:";
-function slug(text2) {
-  return text2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-}
-function findingMarker({ file, title }) {
-  return `${markerPrefix} ${file ?? "n/a"}#${slug(title)} -->`;
-}
-function hasMarker(prior, marker) {
-  return prior.some((comment) => comment.body.includes(marker));
-}
-function withoutMarkers(body) {
-  return body.split("\n").filter((line) => !line.trimStart().startsWith(markerPrefix)).join("\n").trim();
-}
-function heading({ path, line }) {
-  if (!path) return "### PR review";
-  return line === null ? `### ${path}` : `### ${path}:${line}`;
-}
-function formatPriorComments(prior) {
-  if (!prior.length) return "";
-  const blocks = prior.map((comment) => `${heading(comment)}
-
-**${comment.author}**: ${withoutMarkers(comment.body)}`);
-  return `## Prior review comments
-
-The PR already has the review comments below, including resolved and outdated threads. Do not re-raise a finding a prior comment substantively covers.
-
-${blocks.join("\n\n")}
-`;
-}
-
-// src/features/review/findings.ts
-var severities = ["blocker", "major", "minor", "nit"];
-var sources = ["confirmed", "disputed", "reviewer1-only", "reviewer2-only", "already-raised"];
-function oneOf(values, raw) {
-  const value = raw.toLowerCase();
-  return values.find((v) => v === value) ?? null;
-}
-function field(block, name) {
-  return block.match(new RegExp(`^-\\s+${name}:\\s*(.*)$`, "im"))?.[1]?.trim() ?? "";
-}
-function parseLocation(raw) {
-  const location = raw.replace(/^`+|`+$/g, "").trim();
-  if (!location || location.toLowerCase() === "n/a") return { file: null, line: null };
-  const match = location.match(/^(.+?):(\d+)(?:-\d+)?$/);
-  if (!match?.[1] || !match[2]) return { file: location, line: null };
-  return { file: match[1], line: Number(match[2]) };
-}
-function parseFinding(block) {
-  const [heading2 = "", ...rest] = block.split("\n");
-  const body = rest.join("\n");
-  return {
-    title: heading2.trim(),
-    severity: oneOf(severities, field(body, "Severity")),
-    source: oneOf(sources, field(body, "Source")),
-    ...parseLocation(field(body, "Location")),
-    impact: field(body, "Impact"),
-    recommendation: field(body, "Recommendation")
-  };
-}
-function parseSummary(markdown) {
-  return markdown.match(/^##\s+Summary\s*$([\s\S]*?)(?=^##\s|(?![\s\S]))/m)?.[1]?.trim() ?? "";
-}
-function rank(finding) {
-  const severity = finding.severity ? severities.indexOf(finding.severity) : severities.length;
-  const source = finding.source ? sources.indexOf(finding.source) : sources.length;
-  return severity * (sources.length + 1) + source;
-}
-function parseSynthesis(markdown) {
-  const findings = markdown.split(/^###\s+Finding:\s*/m).slice(1).map(parseFinding);
-  return { summary: parseSummary(markdown), findings: findings.toSorted((a, b) => rank(a) - rank(b)) };
+function parseSynthesis(markdown) {
+  const findings = markdown.split(/^###\s+Finding:\s*/m).slice(1).map(parseFinding);
+  return { summary: parseSummary(markdown), findings: findings.toSorted((a, b) => rank(a) - rank(b)) };
 }
 function formatLocation({ file, line }) {
   if (!file) return "no location";
@@ -1281,14 +997,15 @@ This change adds or edits a workflow that calls \`MakerXStudio/yoke/.github/work
 - Calling the workflow at \`@main\` rather than a tag or SHA.
 - The trigger types, including \`synchronize\`: pushes run only the \`review / gate\` job, and a review is re-run by marking the PR as draft and then ready for review.
 - No \`concurrency:\` block, with or without \`synchronize\`: the reusable workflow's \`review\` job skips \`synchronize\` events, so pushes and force-pushes start only gate jobs and don't overlap full reviews.
-- The \`actions: read\` permission: the gate reads earlier runs of the workflow to find the PR's latest review.
+- The \`pull_request_target\` \`labeled\` trigger: a maintainer reads a fork PR's diff, then adds the \`review\` label to run its review with secrets. The reusable workflow runs the review on it only for that label on fork PRs, and refuses to review any commit pushed after the label. Its \`synchronize\` type removes the label when the fork pushes again.
+- The \`actions: write\` and \`statuses: write\` permissions (or \`actions: read\` in older callers): the gate reads earlier runs to find the PR's latest review, records a fork's approved review as a commit status, and re-runs the PR head's gate.
 - Draft PRs being reviewed twice: the reusable workflow already skips drafts.
 
 Real defects in it are still findings, such as:
 
 - Passing every secret with \`secrets: inherit\` instead of only \`REVIEW_CI_API_KEY\` (plus \`REVIEW_CI_BASE_URL\` from callers that still pass the URL as a secret).
 - An input the reusable workflow does not declare.
-- No \`permissions:\` block limiting the token to \`contents: read\` and \`pull-requests: write\`, plus \`id-token: write\` with \`azure-client-id\`. The reusable workflow sets no permissions of its own, so the caller's block is the only limit on the token its agents run with.
+- No \`permissions:\` block limiting the token to \`actions: write\`, \`contents: read\`, \`pull-requests: write\` and \`statuses: write\`, plus \`id-token: write\` with \`azure-client-id\`. The reusable workflow sets no permissions of its own, so the caller's block is the only limit on the token its agents run with.
 `;
 }
 
@@ -1378,11 +1095,11 @@ ${outside.map(outsideEntry).join("\n")}`);
 function postFooter(footer, ci) {
   return [...footer ? [footer] : [], ...ci ? [`_${rerunNote}_`] : []].join("\n\n");
 }
-async function addComments(review, comments, { api, log }) {
+async function addComments(review2, comments, { api, log }) {
   const rejected = [];
   for (const { finding, ...comment } of comments) {
     try {
-      await api.add(review, comment);
+      await api.add(review2, comment);
     } catch (error) {
       if (!(error instanceof ReviewError)) throw error;
       rejected.push(finding);
@@ -1398,18 +1115,18 @@ function failedReviewBody(reason, runUrl, footer = "") {
   return sections.join("\n\n");
 }
 async function postFailure(pr2, reason, runUrl, deps) {
-  const review = await deps.api.open(pr2);
+  const review2 = await deps.api.open(pr2);
   try {
-    const url = await deps.api.submit(pr2, review, failedReviewBody(reason, runUrl, postFooter(deps.footer, true)));
+    const url = await deps.api.submit(pr2, review2, failedReviewBody(reason, runUrl, postFooter(deps.footer, true)));
     deps.log(`posted the failed review: ${url}`);
   } catch (error) {
-    await discard(pr2, review, deps);
+    await discard(pr2, review2, deps);
     throw error;
   }
 }
-async function discard(pr2, review, { api, log }) {
+async function discard(pr2, review2, { api, log }) {
   try {
-    await api.discard(pr2, review);
+    await api.discard(pr2, review2);
   } catch (discardError) {
     log(`could not discard the pending review: ${discardError instanceof Error ? discardError.message : String(discardError)}`);
   }
@@ -1421,17 +1138,17 @@ async function postFindings(pr2, synthesis, diff, prior, deps) {
   const nothingNew = !comments.length && !outside.length;
   if (nothingNew && !ci) return log("nothing new to post");
   const footer = postFooter(deps.footer, ci);
-  const review = await api.open(pr2);
+  const review2 = await api.open(pr2);
   try {
     if (nothingNew) {
-      const url2 = await api.submit(pr2, review, reviewBody(synthesis.summary, [], footer, noFindingsNote));
+      const url2 = await api.submit(pr2, review2, reviewBody(synthesis.summary, [], footer, noFindingsNote));
       return log(`nothing new to post, so posted a review without findings: ${url2}`);
     }
-    const rejected = await addComments(review, comments, deps);
-    const url = await api.submit(pr2, review, reviewBody(synthesis.summary, [...outside, ...rejected], footer));
+    const rejected = await addComments(review2, comments, deps);
+    const url = await api.submit(pr2, review2, reviewBody(synthesis.summary, [...outside, ...rejected], footer));
     log(`posted ${comments.length - rejected.length} inline comment(s) and ${outside.length + rejected.length} in the review body: ${url}`);
   } catch (error) {
-    await discard(pr2, review, deps);
+    await discard(pr2, review2, deps);
     throw error;
   }
 }
@@ -1640,7 +1357,7 @@ async function listModels(settings, fetchModels = fetch) {
 }
 
 // src/features/review/review.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, mkdtempSync, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, mkdtempSync, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir2, tmpdir } from "os";
 import { join as join8 } from "path";
 
@@ -1710,10 +1427,10 @@ async function withEntraToken(settings, { env, fetch: fetchFn = fetch, mask }) {
 
 // src/features/review/harness.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 
 // src/features/review/usage.ts
-import { appendFileSync as appendFileSync2 } from "fs";
+import { appendFileSync } from "fs";
 var fields2 = ["input", "output", "cacheRead", "cacheWrite"];
 var rows = [
   ["reviewer1", "Reviewer 1"],
@@ -1776,7 +1493,7 @@ function writeJobSummary(summary, usage, log, env = process.env) {
   const path = env.GITHUB_STEP_SUMMARY;
   if (!path) return;
   try {
-    appendFileSync2(path, `${jobSummary(summary, usage)}
+    appendFileSync(path, `${jobSummary(summary, usage)}
 `);
     log("wrote the review summary and token usage to the job summary");
   } catch (error) {
@@ -1872,11 +1589,12 @@ function parseHarnessEvent(harness, line) {
 
 // src/features/review/harness.ts
 var tailLines = 20;
-function harnessArgs({ harness, reviewDir, outputPath, override }) {
+function harnessArgs({ harness, reviewDir, outputPath, override, untrusted }) {
   const extra = override?.args ?? [];
   if (harness === "codex") return ["exec", "--sandbox", "read-only", "--json", "--output-last-message", outputPath, ...extra, "-"];
   return [
     "-p",
+    ...untrusted ? ["--setting-sources", "user", "--strict-mcp-config"] : [],
     "--add-dir",
     reviewDir,
     "--disallowedTools",
@@ -1902,7 +1620,7 @@ function exitError(harness, code, output) {
   return [`${harness} exited with code ${code ?? "unknown"}`, ...detail ? [detail] : []].join("\n");
 }
 function hasReview(path) {
-  return existsSync3(path) && readFileSync4(path, "utf8").trim().length > 0;
+  return existsSync3(path) && readFileSync3(path, "utf8").trim().length > 0;
 }
 var runHarness = (run2) => new Promise((resolve3) => {
   const shell = process.platform === "win32";
@@ -1956,11 +1674,11 @@ var runHarness = (run2) => new Promise((resolve3) => {
 import { execFile as execFile2 } from "child_process";
 
 // src/features/review/run.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync6 } from "fs";
 import { join as join6 } from "path";
 
 // src/features/review/cachedSlots.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import { join as join4 } from "path";
 function slotsPath(reviewDir) {
   return join4(reviewDir, "slots.json");
@@ -1971,7 +1689,7 @@ function isCachedSlots(value) {
 function readCachedSlots(reviewDir) {
   const path = slotsPath(reviewDir);
   if (!existsSync4(path)) return {};
-  const parsed = JSON.parse(readFileSync5(path, "utf8"));
+  const parsed = JSON.parse(readFileSync4(path, "utf8"));
   return isCachedSlots(parsed) ? parsed : {};
 }
 function cachedSlot(reviewDir, step) {
@@ -2125,7 +1843,7 @@ ${files.join("\n")}
 }
 
 // src/features/review/usedModels.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
 import { join as join5 } from "path";
 var repoUrl = "https://github.com/MakerXStudio/yoke";
 function modelsPath(reviewDir) {
@@ -2137,7 +1855,7 @@ function isUsedModels(value) {
 function readUsedModels(reviewDir) {
   const path = modelsPath(reviewDir);
   if (!existsSync5(path)) return {};
-  const parsed = JSON.parse(readFileSync6(path, "utf8"));
+  const parsed = JSON.parse(readFileSync5(path, "utf8"));
   return isUsedModels(parsed) ? parsed : {};
 }
 function recordUsedModel(reviewDir, step, harness, model) {
@@ -2190,6 +1908,7 @@ async function runStep({ name, label, slot, ...step }, context) {
     ...step,
     harness,
     override,
+    untrusted: context.untrusted,
     cwd: context.cwd,
     reviewDir: context.reviewDir,
     onProgress: status.update
@@ -2208,7 +1927,7 @@ async function runStep({ name, label, slot, ...step }, context) {
 }
 function hasOutput({ name, slot, outputPath }, context) {
   if (cachedSlot(context.reviewDir, name) !== describeSlot(slot)) return false;
-  return existsSync6(outputPath) && readFileSync7(outputPath, "utf8").trim().length > 0;
+  return existsSync6(outputPath) && readFileSync6(outputPath, "utf8").trim().length > 0;
 }
 async function runOrReuse(step, context) {
   if (!hasOutput(step, context)) return { ok: await runStep(step, context), ran: true };
@@ -2235,7 +1954,7 @@ function synthesisResult(markdown) {
 function rawReviews(succeeded, context) {
   const report = succeeded.map((reviewer) => `# ${reviewerLabel(reviewer, context)} review
 
-${readFileSync7(reviewPath(context, reviewer), "utf8").trim()}`).join("\n\n");
+${readFileSync6(reviewPath(context, reviewer), "utf8").trim()}`).join("\n\n");
   return { report, synthesis: null, markdown: null };
 }
 function synthesisSlot(succeeded, context) {
@@ -2252,7 +1971,7 @@ async function synthesise(requestPath, succeeded, reviewersRan, context) {
   }));
   const prompt = buildSynthesisPrompt(requestPath, files);
   if ((await runOrReuse({ name: "synthesis", label: `synthesis (${describeSlot(slot)})`, slot, prompt, outputPath }, context)).ok)
-    return synthesisResult(readFileSync7(outputPath, "utf8"));
+    return synthesisResult(readFileSync6(outputPath, "utf8"));
   if (context.strict) throw new ReviewFailure("synthesis failed", "The synthesis failed; nothing to post.");
   context.log("showing the raw reviews instead");
   return rawReviews(succeeded, context);
@@ -2360,21 +2079,21 @@ async function assertViable(slots2, check = checks) {
 }
 
 // src/features/review/reviewLog.ts
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3 } from "fs";
 import { join as join7 } from "path";
 function reviewLog(command = process.argv.slice(2), now = () => /* @__PURE__ */ new Date()) {
   let path;
   let buffered = [];
   return {
     append: (line) => {
-      if (path) appendFileSync3(path, `${line}
+      if (path) appendFileSync2(path, `${line}
 `);
       else buffered.push(line);
     },
     attach: (reviewDir) => {
       mkdirSync3(reviewDir, { recursive: true });
       path = join7(reviewDir, "review.log");
-      appendFileSync3(path, `${["", `=== ${now().toISOString()} ===`, `$ yoke ${command.join(" ")}`, ...buffered].join("\n")}
+      appendFileSync2(path, `${["", `=== ${now().toISOString()} ===`, `$ yoke ${command.join(" ")}`, ...buffered].join("\n")}
 `);
       buffered = [];
     }
@@ -2418,12 +2137,12 @@ function prepareRunDir(reviewDir, force) {
   mkdirSync4(reviewDir, { recursive: true });
   if (force) for (const name of cachedOutputs) rmSync2(join8(reviewDir, name), { force: true });
 }
-async function reviewAtHead(pr2, reviewDir, request, slots2, ui, strict) {
+async function reviewAtHead(pr2, reviewDir, request, slots2, ui, { strict, untrusted }) {
   const checkoutDir = mkdtempSync(join8(tmpdir(), "yoke-review-"));
   try {
     const checkout = await timed(ui, `checking out ${pr2.headRefOid.slice(0, 7)}`, () => checkoutHead(pr2, checkoutDir));
     try {
-      return await runReview(request, { cwd: checkout.cwd, reviewDir, slots: slots2, runHarness, log: ui.log, track: ui.track, strict });
+      return await runReview(request, { cwd: checkout.cwd, reviewDir, slots: slots2, runHarness, log: ui.log, track: ui.track, strict, untrusted });
     } finally {
       await checkout.remove();
     }
@@ -2433,13 +2152,19 @@ async function reviewAtHead(pr2, reviewDir, request, slots2, ui, strict) {
 }
 function savedReview(path, post) {
   if (!post || !existsSync7(path)) return null;
-  return parseSynthesis(readFileSync8(path, "utf8"));
+  return parseSynthesis(readFileSync7(path, "utf8"));
+}
+function assertHead(pr2, head) {
+  if (head && pr2.headRefOid !== head)
+    throw new ReviewError(
+      `#${pr2.number} moved from ${head.slice(0, 7)} to ${pr2.headRefOid.slice(0, 7)}, so its new commits were not approved; not reviewing it`
+    );
 }
 function saveReview(path, markdown) {
   if (markdown) writeFileSync7(path, markdown);
   else rmSync2(path, { force: true });
 }
-async function reviewPr(number, settings, { post, force }, io) {
+async function reviewPr(number, settings, { post, force, head }, io) {
   const file = reviewLog();
   const ui = logged(io.ui, file.append);
   const out = (text2) => {
@@ -2455,11 +2180,12 @@ async function reviewPr(number, settings, { post, force }, io) {
     "fetching the diff and earlier review comments",
     () => Promise.all([fetchDiff(pr2), fetchPriorComments(pr2)])
   );
+  assertHead(pr2, head);
   const reviewDir = reviewRunDir(pr2);
   prepareRunDir(reviewDir, force);
   file.attach(reviewDir);
   const ci = post && isCi();
-  const review = async () => {
+  const review2 = async () => {
     const path = join8(reviewDir, "review.md");
     const saved = savedReview(path, post);
     if (saved) {
@@ -2469,7 +2195,10 @@ async function reviewPr(number, settings, { post, force }, io) {
     }
     await timed(ui, "checking each reviewer can run", () => assertViable(slots2));
     log(`review folder: ${reviewDir}`);
-    const result = await reviewAtHead(pr2, reviewDir, buildRequest(pr2, diff, prior), slots2, ui, ci);
+    const result = await reviewAtHead(pr2, reviewDir, buildRequest(pr2, diff, prior), slots2, ui, {
+      strict: ci,
+      untrusted: head !== void 0
+    });
     out(result.report);
     saveReview(path, result.markdown);
     if (post && !result.synthesis)
@@ -2482,7 +2211,7 @@ async function reviewPr(number, settings, { post, force }, io) {
   const footer = () => modelsFooter(readUsedModels(reviewDir));
   let findings;
   try {
-    const { synthesis: synthesis2, usage } = await review();
+    const { synthesis: synthesis2, usage } = await review2();
     findings = synthesis2;
     if (ci && synthesis2) writeJobSummary(synthesis2.summary, usage, log);
   } catch (error) {
@@ -2495,7 +2224,7 @@ async function reviewPr(number, settings, { post, force }, io) {
 }
 
 // src/features/sync/sync.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join9 } from "path";
 
@@ -2535,7 +2264,7 @@ var reviewCiGateSkill = {
   disableModelInvocation: true,
   userLevel: true,
   body: `
-Run \`yoke review-ci-gate\` and relay its output.
+Run \`yoke review ci-gate\` and relay its output.
 
 If it fails, say what is missing and how to fix it, as it reports. Don't create the ruleset any other way.
 
@@ -2556,13 +2285,13 @@ Read \`.github/workflows/\`, recent review runs (\`gh run list\`, \`gh run view
 
 A workflow is an LLM review if it has a model review PRs, whatever tool it uses.
 
-- **None:** run \`yoke review-ci $ARGUMENTS\`.
-- **One, not yoke's:** run \`yoke review-ci $ARGUMENTS --print\` with its provider and models, then edit that file in place to run yoke's review. Keep its name, triggers, provider, models, base URL, variable and secret names.
+- **None:** run \`yoke review ci $ARGUMENTS\`.
+- **One, not yoke's:** run \`yoke review ci $ARGUMENTS --print\` with its provider and models, then edit that file in place to run yoke's review. Keep its name, triggers, provider, models, base URL, variable and secret names.
 - **Already yoke's** (calls MakerXStudio/yoke's \`review.yml\`, or \`./.github/workflows/review.yml\` in yoke itself): compare with \`--print\` and add only what is missing.
 
 Never ask whether to overwrite a workflow. If \`review-pr.yml\` exists and differs, edit it in place.
 
-The \`review / gate\` merge gate needs the \`synchronize\` trigger and \`actions: read\` permission from \`--print\`; add them to an edited workflow if missing.
+The \`review / gate\` merge gate needs the \`synchronize\` trigger, the \`pull_request_target\` \`labeled\` and \`synchronize\` triggers, and the \`actions: write\` and \`statuses: write\` permissions from \`--print\`; add them to an edited workflow if missing.
 
 If no workflow or setting names the models, ask which model each reviewer runs. For LiteLLM, offer \`yoke models\`. For Foundry, ask for deployment names.
 
@@ -2603,7 +2332,7 @@ function skillsRoot(user, cwd = process.cwd(), home = homedir3()) {
   return join9(user ? home : cwd, ".claude", "skills");
 }
 function isOwnedByUser(skillFile) {
-  return existsSync8(skillFile) && !readFileSync9(skillFile, "utf8").includes(ownerMarker);
+  return existsSync8(skillFile) && !readFileSync8(skillFile, "utf8").includes(ownerMarker);
 }
 function syncSkills(destination, userDestination, force = false, skills = bundledSkills) {
   const result = { written: [], skipped: [] };
@@ -2659,14 +2388,14 @@ function detectInstall(dir, globalRoot = npmGlobalRoot, toplevel = gitToplevel)
 }
 
 // src/features/update/targets.ts
-import { existsSync as existsSync9, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join10, resolve as resolve2 } from "path";
 function holdsYokeSkill(root, skills) {
   return skills.some((skill) => {
     if (skill.userLevel) return false;
     const file = join10(root, skill.name, "SKILL.md");
-    return existsSync9(file) && readFileSync10(file, "utf8").includes(ownerMarker);
+    return existsSync9(file) && readFileSync9(file, "utf8").includes(ownerMarker);
   });
 }
 function syncTargets(cwd = process.cwd(), home = homedir4(), skills = bundledSkills) {
@@ -2731,96 +2460,562 @@ function updateYoke({ dir, install, targets, run: run2 = runInherited, log, erro
   return 0;
 }
 
-// src/cli.ts
-var { version } = package_default;
-var program = new Command("yoke").description("Lean Claude Code skills and the CLI they call.").version(version);
-program.command("sync").description("Write yoke's skills into this repo's .claude/skills, or ~/.claude/skills with --user").option("--user", "write to ~/.claude/skills instead, for every repo").option("--force", "overwrite same-named skills that yoke didn't write").action((options) => {
-  const user = options.user ?? false;
-  const cwd = process.cwd();
-  const display = (path) => path.startsWith(cwd) ? relative2(cwd, path) : path;
-  const { written, skipped } = syncSkills(skillsRoot(user), skillsRoot(true), options.force ?? false);
-  for (const file of written) console.log(`wrote ${display(file)}`);
-  for (const dir of skipped) console.log(`skipped ${display(dir)} (not yoke's skill; rerun with --force to overwrite it)`);
-});
-program.command("update").description("Update yoke to the latest version, then re-sync its skills wherever they were synced before").action(() => {
-  const dir = installDir();
-  process.exitCode = updateYoke({
-    dir,
-    install: detectInstall(dir),
-    targets: () => syncTargets(),
-    log: console.log,
-    error: console.error
-  });
-});
-var pr = program.command("pr").description("Pull request commands");
-pr.command("raise").description("Validate a PR title and body, then create the PR with gh").requiredOption("--title <title>", "single-line PR title").requiredOption("--body <body>", "PR body with ## What, ## Why and optionally ## How").option("--base <branch>", "base branch (defaults to the repo default)").option("--no-draft", "create a ready-for-review PR instead of a draft").addHelpText("after", raiseGuide).action((options) => {
-  try {
-    console.log(raisePr(options));
-  } catch (error) {
-    if (!(error instanceof PrValidationError)) throw error;
-    console.error(error.message);
-    process.exitCode = 1;
-  }
+// src/features/review/ciGate.ts
+import { z as z3 } from "zod";
+
+// src/features/review/ciGateCaller.ts
+import { parse } from "yaml";
+import { z as z2 } from "zod";
+var yokeRepo = "MakerXStudio/yoke";
+var localReviewWorkflow = "./.github/workflows/review.yml";
+var reviewWorkflowPrefix = reviewWorkflowRef.slice(0, reviewWorkflowRef.indexOf("@") + 1).toLowerCase();
+var workflowSchema = z2.looseObject({
+  on: z2.unknown().optional(),
+  permissions: z2.unknown().optional(),
+  jobs: z2.record(z2.string(), z2.looseObject({ uses: z2.unknown().optional(), permissions: z2.unknown().optional() }).nullable()).optional()
 });
-var providerKeys = settingKeys.filter((key) => !key.startsWith("review."));
-addSettingOptions(
-  program.command("review").description("Review the current branch's PR, or PR <number>, with Claude and Codex in parallel, then combine their findings").argument("[number]", "PR number; reviewed without checking it out").option("--post", "post the findings to the PR as one review, reusing the saved review of the PR head when there is one").option("--force", "discard this PR head's cached reviews and run every pass again").option("--verbose", "print every step and each reviewer's tool calls as log lines instead of live spinners"),
-  settingKeys
-).addHelpText("after", settingsHelp).action(async (number, options) => {
-  const verbose = options.verbose ?? false;
-  const ui = process.stderr.isTTY && !verbose ? spinnerUi(process.stderr) : lineUi(console.error, { activity: verbose });
+function parseWorkflow(content) {
   try {
-    const settings = resolveSettings(flagSettings(options, settingKeys), process.env, readUserConfig(userConfigPath()));
-    const run2 = { post: options.post ?? false, force: options.force ?? false };
-    await reviewPr(number, settings, run2, { out: console.log, ui });
-  } catch (error) {
-    if (!(error instanceof ReviewError || error instanceof ConfigError)) throw error;
-    console.error(error.message);
-    process.exitCode = 1;
-  } finally {
-    ui.stop();
+    const result = workflowSchema.safeParse(parse(content));
+    return result.success ? result.data : void 0;
+  } catch {
+    return void 0;
   }
+}
+function callsReview(uses, repo) {
+  if (typeof uses !== "string") return false;
+  if (uses.toLowerCase().startsWith(reviewWorkflowPrefix)) return true;
+  return repo.toLowerCase() === yokeRepo.toLowerCase() && uses === localReviewWorkflow;
+}
+function listIncludes(value, item) {
+  return value === item || Array.isArray(value) && value.includes(item);
+}
+function property(value, key) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  return new Map(Object.entries(value)).get(key);
+}
+function eventTrigger(on, event) {
+  const trigger = property(on, event);
+  return typeof trigger === "object" && trigger !== null && !Array.isArray(trigger) ? { ...trigger } : void 0;
+}
+function runsOn(on, event, type, byDefault) {
+  if (typeof on === "string" || Array.isArray(on)) return byDefault && listIncludes(on, event);
+  if (typeof on !== "object" || on === null || !(event in on)) return false;
+  const trigger = eventTrigger(on, event);
+  if (!trigger || !("types" in trigger)) return byDefault;
+  return listIncludes(trigger.types, type);
+}
+function globMatches(pattern, branch) {
+  const source = pattern.split(/(\*\*|\*|\?)/).map((part) => ({ "**": ".*", "*": "[^/]*", "?": "." })[part] ?? part.replace(/[.+^${}()|[\]\\]/g, "\\$&")).join("");
+  return new RegExp(`^${source}$`).test(branch);
+}
+function patterns(value) {
+  if (typeof value === "string") return [value];
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function branchesInclude(value, branch) {
+  return patterns(value).reduce(
+    (included, pattern) => pattern.startsWith("!") ? included && !globMatches(pattern.slice(1), branch) : included || globMatches(pattern, branch),
+    false
+  );
+}
+function skipFilters(on, event, branch) {
+  const trigger = eventTrigger(on, event);
+  if (!trigger) return [];
+  const filters = ["paths", "paths-ignore"].filter((key) => key in trigger);
+  if ("branches" in trigger && !branchesInclude(trigger.branches, branch)) filters.push("branches");
+  if ("branches-ignore" in trigger && patterns(trigger["branches-ignore"]).some((pattern) => globMatches(pattern, branch)))
+    filters.push("branches-ignore");
+  return filters;
+}
+function canWrite(permissions, scope) {
+  if (permissions === "write-all") return true;
+  return property(permissions, scope) === "write";
+}
+var writeScopes = ["actions", "statuses"];
+function filterProblem(on, event, branch) {
+  const filters = skipFilters(on, event, branch);
+  if (filters.length === 0) return [];
+  const named = filters.map((filter) => `\`${filter}\``).join(", ");
+  return [
+    `skips some PRs to ${branch} through its \`${event}\` ${named} filter${filters.length > 1 ? "s" : ""}, so those PRs could never merge`
+  ];
+}
+function checkWorkflow(path, workflow, repo, branch) {
+  const jobs = Object.values(workflow.jobs ?? {}).filter((job) => job && callsReview(job.uses, repo));
+  if (jobs.length === 0) return void 0;
+  const problems2 = [];
+  if (!runsOn(workflow.on, "pull_request", "synchronize", true)) problems2.push("lacks the `synchronize` type in its `pull_request` trigger");
+  if (!runsOn(workflow.on, "pull_request_target", "labeled", false))
+    problems2.push("lacks a `pull_request_target` trigger with the `labeled` type, so fork PRs can never pass the gate");
+  else if (!runsOn(workflow.on, "pull_request_target", "synchronize", true))
+    problems2.push(
+      "lacks the `synchronize` type in its `pull_request_target` trigger, so a push to an approved fork PR keeps the `review` label and a maintainer can't re-approve it"
+    );
+  const missing = writeScopes.filter((scope) => !jobs.some((job) => canWrite(job?.permissions ?? workflow.permissions, scope)));
+  if (missing.length > 0) problems2.push(`lacks ${missing.map((scope) => `\`${scope}: write\``).join(" and ")} in its permissions`);
+  problems2.push(...filterProblem(workflow.on, "pull_request", branch), ...filterProblem(workflow.on, "pull_request_target", branch));
+  return { path, problems: problems2 };
+}
+function checkCallerWorkflows(files, repo, branch) {
+  const callers = files.flatMap(({ path, content }) => {
+    const workflow = parseWorkflow(content);
+    const check = workflow && checkWorkflow(path, workflow, repo, branch);
+    return check ? [check] : [];
+  });
+  return callers.find((caller) => caller.problems.length === 0) ?? callers[0];
+}
+
+// src/features/review/ciGate.ts
+var gateRuleset = {
+  name: "yoke review",
+  target: "branch",
+  enforcement: "active",
+  conditions: { ref_name: { include: ["~DEFAULT_BRANCH"], exclude: [] } },
+  rules: [
+    {
+      type: "required_status_checks",
+      parameters: { strict_required_status_checks_policy: false, required_status_checks: [{ context: gateCheck }] }
+    }
+  ]
+};
+var recentPrCount = 20;
+var repoSchema = z3.object({
+  full_name: z3.string(),
+  html_url: z3.string(),
+  default_branch: z3.string()
 });
-var ciKeys = settingKeys.filter((key) => /^review\.\w+\.(harness|model)$/.test(key));
-addSettingOptions(
-  program.command("review-ci").description(
-    `Write ${callerWorkflowPath} so each PR in this repo is reviewed in CI, then print the secrets, or Entra federated credential, it needs`
-  ).option("--provider <provider>", "litellm or foundry; every slot uses it in CI. Default: review.reviewer1.provider, else litellm").option(
-    "--azure-client-id <id>",
-    "Entra app (client) ID to sign in to Foundry with GitHub OIDC instead of an API key; needs --provider foundry"
-  ).option("--azure-tenant-id <id>", "Entra tenant ID of that app").option("--environment <name>", "GitHub environment the review job runs in, matching the app's federated credential subject").option("--print", `print the workflow and setup commands without writing ${callerWorkflowPath}`),
-  ciKeys
-).addHelpText("after", settingsHelp).action((options) => {
+var branchRulesSchema = z3.array(
+  z3.object({
+    type: z3.string(),
+    ruleset_id: z3.number().optional(),
+    parameters: z3.object({ required_status_checks: z3.array(z3.object({ context: z3.string() })).optional() }).optional()
+  })
+);
+var directorySchema = z3.array(z3.object({ type: z3.string(), name: z3.string(), path: z3.string() }));
+var fileSchema = z3.object({ content: z3.string() });
+var pullsSchema = z3.array(z3.object({ head: z3.object({ sha: z3.string() }) }));
+var checkRunsSchema = z3.object({ total_count: z3.number() });
+var createdSchema = z3.object({ id: z3.number() });
+var rulesetsSchema = z3.array(z3.object({ id: z3.number(), name: z3.string(), enforcement: z3.string() }));
+var githubApi = { get: (path) => githubGet(path), post: (path, body) => githubPost(path, body) };
+async function getUnlessMissing(api, path) {
   try {
-    const settings = resolveSettings(flagSettings(options, ciKeys), process.env, readUserConfig(userConfigPath()));
-    const workflow = callerWorkflow(settings, options.provider, options);
-    const root = repoRoot();
-    const outcome = options.print ? "printed" : writeCallerWorkflow(root, renderCallerWorkflow(workflow));
-    console.log(reviewCiReport(outcome, settings, workflow, () => githubRepo(root)));
+    return await api.get(path);
   } catch (error) {
-    if (!(error instanceof ReviewError || error instanceof ConfigError)) throw error;
-    console.error(error.message);
-    process.exitCode = 1;
+    if (error instanceof ReviewError && error.message.includes("(HTTP 404)")) return void 0;
+    throw error;
   }
-});
-program.command("review-ci-gate").description(`Require the ${gateCheck} check on the default branch with a ruleset, once the CI review workflow is merged`).action(async () => {
+}
+async function workflowFiles(api, repo) {
+  const ref = `ref=${encodeURIComponent(repo.default_branch)}`;
+  const listing = await getUnlessMissing(api, `repos/${repo.full_name}/contents/.github/workflows?${ref}`);
+  if (listing === void 0) return [];
+  const files = directorySchema.parse(listing).filter((entry) => entry.type === "file" && /\.ya?ml$/.test(entry.name));
+  return Promise.all(
+    files.map(async ({ path }) => {
+      const { content } = fileSchema.parse(await api.get(`repos/${repo.full_name}/contents/${path}?${ref}`));
+      return { path, content: Buffer.from(content, "base64").toString("utf8") };
+    })
+  );
+}
+async function callerProblem(api, repo) {
+  const branch = repo.default_branch;
+  const caller = checkCallerWorkflows(await workflowFiles(api, repo), repo.full_name, branch);
+  if (!caller) return `No workflow on ${branch} calls yoke's review.yml. Run /review-ci, then merge its ${callerWorkflowPath} to ${branch}.`;
+  if (caller.problems.length > 0)
+    return `${caller.path} on ${branch} calls yoke's review.yml but ${caller.problems.join(" and ")}. Fix it and merge the change to ${branch}.`;
+  return void 0;
+}
+async function gateHasReported(api, repo) {
+  const pulls = pullsSchema.parse(
+    await api.get(`repos/${repo.full_name}/pulls?state=all&sort=updated&direction=desc&per_page=${recentPrCount}`)
+  );
+  for (const { head } of pulls) {
+    const runs = checkRunsSchema.parse(
+      await api.get(`repos/${repo.full_name}/commits/${head.sha}/check-runs?check_name=${encodeURIComponent(gateCheck)}&per_page=1`)
+    );
+    if (runs.total_count > 0) return true;
+  }
+  return false;
+}
+async function rulesetProblem(api, repo) {
+  const rulesets = rulesetsSchema.parse(await api.get(`repos/${repo.full_name}/rulesets?includes_parents=false&per_page=100`));
+  const existing = rulesets.find((ruleset) => ruleset.name === gateRuleset.name);
+  if (!existing) return void 0;
+  return `The "${gateRuleset.name}" ruleset already exists with enforcement \`${existing.enforcement}\` but doesn't require ${gateCheck} on ${repo.default_branch}: ${repo.html_url}/rules/${existing.id}. Set its enforcement to Active and its required check to ${gateCheck}, or delete it and run this again.`;
+}
+async function createRuleset(api, repo) {
   try {
-    console.log((await enforceReviewGate()).message);
+    return await api.post(`repos/${repo.full_name}/rulesets`, gateRuleset);
   } catch (error) {
-    if (!(error instanceof ReviewError)) throw error;
-    console.error(error.message);
-    process.exitCode = 1;
+    if (error instanceof ReviewError && /\(HTTP 40[34]\)/.test(error.message))
+      throw new ReviewError(
+        `GitHub refused to add the "${gateRuleset.name}" ruleset to ${repo.full_name}: your gh user can't edit its repository rules. Ask a repo admin, or someone whose role can edit repository rules, to run \`yoke review ci-gate\`.`
+      );
+    throw error;
   }
+}
+async function problems(api, repo) {
+  const found = [];
+  const ruleset = await rulesetProblem(api, repo);
+  if (ruleset) found.push(ruleset);
+  const caller = await callerProblem(api, repo);
+  if (caller) found.push(caller);
+  if (!await gateHasReported(api, repo))
+    found.push(
+      `No ${gateCheck} check run on the ${recentPrCount} most recently updated PRs. Open or push to a PR so the gate reports, then run this again.`
+    );
+  return found;
+}
+async function enforceReviewGate(api = githubApi) {
+  const repo = repoSchema.parse(await api.get("repos/{owner}/{repo}"));
+  const branch = repo.default_branch;
+  const rules = branchRulesSchema.parse(await api.get(`repos/${repo.full_name}/rules/branches/${encodeURIComponent(branch)}`));
+  const existing = rules.find(
+    (rule) => rule.type === "required_status_checks" && rule.parameters?.required_status_checks?.some((check) => check.context === gateCheck)
+  );
+  if (existing) {
+    const where = existing.ruleset_id ? ` by ${repo.html_url}/rules/${existing.ruleset_id}` : "";
+    return { created: false, message: `${gateCheck} is already required on ${branch}${where}; nothing changed.` };
+  }
+  const found = await problems(api, repo);
+  if (found.length > 0)
+    throw new ReviewError([`Cannot require ${gateCheck} on ${branch} yet:`, ...found.map((problem) => `- ${problem}`)].join("\n"));
+  const { id } = createdSchema.parse(await createRuleset(api, repo));
+  return {
+    created: true,
+    message: `Added the "${gateRuleset.name}" ruleset, which blocks merging to ${branch} until ${gateCheck} passes: ${repo.html_url}/rules/${id}`
+  };
+}
+
+// src/features/review/gate.ts
+import { appendFileSync as appendFileSync3, readFileSync as readFileSync10 } from "fs";
+import { setTimeout } from "timers/promises";
+import { z as z6 } from "zod";
+
+// src/features/review/gateHandoff.ts
+import { z as z5 } from "zod";
+
+// src/features/review/approver.ts
+import { z as z4 } from "zod";
+var permissionSchema = z4.object({ permission: z4.string(), role_name: z4.string().optional() });
+var approverPermissions = /* @__PURE__ */ new Set(["admin", "write"]);
+async function approverRejection({ repo, event }, get2) {
+  const login = event.sender?.login;
+  if (!login) return "was not run: the label event names no sender to check";
+  const { permission, role_name } = permissionSchema.parse(await get2(`repos/${repo}/collaborators/${login}/permission`));
+  if (approverPermissions.has(permission)) return void 0;
+  return `was not run: ${login} added the label with ${role_name ?? permission} access; approving needs write, maintain or admin`;
+}
+
+// src/features/review/gateHandoff.ts
+var approvedReviewContext = "review / approved review";
+var reviewLabel = "review";
+var runPollInterval = 15e3;
+var runSchema = z5.object({ id: z5.number(), run_number: z5.number(), status: z5.string().nullable() });
+var runsSchema = z5.object({ workflow_runs: z5.array(runSchema) });
+var jobsSchema = z5.object({ jobs: z5.array(z5.object({ id: z5.number(), name: z5.string() })) });
+var statusesSchema = z5.array(z5.object({ context: z5.string(), target_url: z5.string().nullable() }));
+var pendingResult = "pending";
+function approvalState(reviewResult) {
+  if (reviewResult === pendingResult) return { state: "pending", description: "is running" };
+  return { state: reviewResult === "success" ? "success" : "failure", description: `finished with ${reviewResult}` };
+}
+async function postApproval(approval, { repo, runId, serverUrl, event }, deps) {
+  await deps.post(`repos/${repo}/statuses/${event.pull_request.head.sha}`, {
+    ...approval,
+    context: approvedReviewContext,
+    target_url: `${serverUrl}/${repo}/actions/runs/${runId}`
+  });
+}
+async function newerApprovalRun({ repo, runId, runNumber, event }, deps) {
+  const statuses = statusesSchema.parse(await deps.get(`repos/${repo}/commits/${event.pull_request.head.sha}/statuses?per_page=100`));
+  const owner = statuses.find((status) => status.context === approvedReviewContext)?.target_url ?? "";
+  const id = /\/actions\/runs\/(\d+)/.exec(owner)?.[1];
+  if (!id || id === runId) return void 0;
+  const { run_number } = runSchema.parse(await deps.get(`repos/${repo}/actions/runs/${id}`));
+  return run_number > runNumber ? owner : void 0;
+}
+async function latestPullRequestRun({ repo, runId, event }, deps) {
+  const { workflow_id } = z5.object({ workflow_id: z5.number() }).parse(await deps.get(`repos/${repo}/actions/runs/${runId}`));
+  const query = new URLSearchParams({ event: "pull_request", head_sha: event.pull_request.head.sha, per_page: "100" });
+  const { workflow_runs } = runsSchema.parse(await deps.get(`repos/${repo}/actions/workflows/${workflow_id}/runs?${query.toString()}`));
+  return workflow_runs.toSorted((a, b) => b.run_number - a.run_number)[0];
+}
+async function settledRun(repo, id, status, deps) {
+  while (status !== "completed") {
+    deps.log(`Waiting for run ${id} to finish (${status}) before re-running its gate`);
+    await deps.sleep(runPollInterval);
+    ({ status } = runSchema.parse(await deps.get(`repos/${repo}/actions/runs/${id}`)));
+  }
+}
+async function rerunHeadGate(context, deps) {
+  const { repo, serverUrl } = context;
+  const sha = context.event.pull_request.head.sha.slice(0, 7);
+  const run2 = await latestPullRequestRun(context, deps);
+  if (!run2) return `No pull_request run of this workflow exists for ${sha}; its gate reads this result when it runs.`;
+  await settledRun(repo, run2.id, run2.status, deps);
+  const { jobs } = jobsSchema.parse(await deps.get(`repos/${repo}/actions/runs/${run2.id}/jobs`));
+  const gate2 = jobs.find((job) => job.name.endsWith(" / gate"));
+  const url = `${serverUrl}/${repo}/actions/runs/${run2.id}`;
+  if (!gate2) return `Run ${url} for ${sha} has no gate job to re-run; its gate reads this result when it runs.`;
+  await deps.post(`repos/${repo}/actions/jobs/${gate2.id}/rerun`, {});
+  return `Re-ran the gate for ${sha} in ${url}.`;
+}
+async function handOffApprovedReview(reviewResult, context, deps) {
+  const { action, label } = context.event;
+  if (action !== "labeled" || label?.name !== reviewLabel || reviewResult === "skipped")
+    return { pass: true, message: "No approved review ran on this event." };
+  const rejection = await approverRejection(context, deps.get);
+  const newer = await newerApprovalRun(context, deps);
+  if (rejection) {
+    if (newer) return { pass: false, message: `The review ${rejection}. A newer approved review, in ${newer}, owns the result.` };
+    await postApproval({ state: "failure", description: rejection }, context, deps);
+    return { pass: false, message: `The review ${rejection}. ${await rerunHeadGate(context, deps)}` };
+  }
+  if (newer)
+    return {
+      pass: reviewResult === pendingResult || reviewResult === "success",
+      message: `A newer approved review, in ${newer}, owns the result for ${context.event.pull_request.head.sha.slice(0, 7)}, so this run's ${reviewResult} is not recorded.`
+    };
+  await postApproval(approvalState(reviewResult), context, deps);
+  const rerun = await rerunHeadGate(context, deps);
+  if (reviewResult === pendingResult) return { pass: true, message: `Marked the review a maintainer approved as running. ${rerun}` };
+  const pass = reviewResult === "success";
+  return { pass, message: `The review a maintainer approved finished with ${reviewResult}. ${rerun}` };
+}
+
+// src/features/review/gate.ts
+var eventSchema = z6.object({
+  action: z6.string(),
+  label: z6.object({ name: z6.string() }).optional(),
+  sender: z6.object({ login: z6.string() }).optional(),
+  pull_request: z6.object({
+    number: z6.number(),
+    head: z6.object({ ref: z6.string(), sha: z6.string(), repo: z6.object({ full_name: z6.string() }).nullable() }),
+    user: z6.object({ type: z6.string() }),
+    labels: z6.array(z6.object({ name: z6.string() })).optional()
+  })
+});
+var runsSchema2 = z6.object({
+  workflow_runs: z6.array(z6.object({ id: z6.number(), run_number: z6.number(), pull_requests: z6.array(z6.object({ number: z6.number() })) }))
 });
-program.command("review-gate").description("Block merging until the latest review that ran for the PR succeeds; fork and bot PRs pass. Used by review.yml's gate job").argument("<result>", "result of the review job on this event: success, failure, cancelled or skipped").action(async (result) => {
+var jobsSchema2 = z6.object({ jobs: z6.array(z6.object({ name: z6.string(), status: z6.string(), conclusion: z6.string().nullable() })) });
+var statusesSchema2 = z6.array(
+  z6.object({ context: z6.string(), state: z6.string(), description: z6.string().nullable(), target_url: z6.string().nullable() })
+);
+var pollInterval = 3e4;
+var rerunHint = "Mark the PR as draft, then ready for review, to run the review again.";
+var firstRunHint = "Mark the PR as ready for review (from draft if it is not one) to run it.";
+var forkHint = "The review does not run automatically on PRs from forks. A maintainer must read the diff, then add the `review` label to run it. If adding the label runs nothing, the caller workflow needs the `pull_request_target` `labeled` and `synchronize` triggers and the `actions: write` and `statuses: write` permissions; run `yoke review ci` to update it.";
+var forkRerunHint = "A maintainer must read the diff, then remove and add the `review` label again to re-run it.";
+function verdict(conclusion, message) {
+  const pass = conclusion === "success";
+  return { pass, message: pass ? message : `${message} ${rerunHint}` };
+}
+function gateContext(env = process.env, command = "yoke review gate") {
+  const { GITHUB_REPOSITORY, GITHUB_RUN_ID, GITHUB_RUN_NUMBER, GITHUB_SERVER_URL, GITHUB_EVENT_PATH, GITHUB_EVENT_NAME } = env;
+  if (!GITHUB_REPOSITORY || !GITHUB_RUN_ID || !GITHUB_RUN_NUMBER || !GITHUB_SERVER_URL || !GITHUB_EVENT_PATH || !GITHUB_EVENT_NAME) {
+    throw new ReviewError(`${command} runs only in a GitHub Actions pull_request workflow`);
+  }
+  const event = eventSchema.safeParse(JSON.parse(readFileSync10(GITHUB_EVENT_PATH, "utf8")));
+  if (!event.success || GITHUB_EVENT_NAME !== "pull_request" && GITHUB_EVENT_NAME !== "pull_request_target")
+    throw new ReviewError(`${command} runs only on pull_request and pull_request_target events`);
+  return {
+    repo: GITHUB_REPOSITORY,
+    runId: GITHUB_RUN_ID,
+    runNumber: Number(GITHUB_RUN_NUMBER),
+    serverUrl: GITHUB_SERVER_URL,
+    eventName: GITHUB_EVENT_NAME,
+    event: event.data
+  };
+}
+async function earlierRuns({ repo, runId, runNumber, event }, deps) {
+  const { workflow_id } = z6.object({ workflow_id: z6.number() }).parse(await deps.get(`repos/${repo}/actions/runs/${runId}`));
+  const query = new URLSearchParams({ event: "pull_request", branch: event.pull_request.head.ref, per_page: "100" });
+  const { workflow_runs } = runsSchema2.parse(await deps.get(`repos/${repo}/actions/workflows/${workflow_id}/runs?${query.toString()}`));
+  return workflow_runs.filter((run2) => run2.run_number < runNumber && run2.pull_requests.some((pr2) => pr2.number === event.pull_request.number)).toSorted((a, b) => b.run_number - a.run_number).map((run2) => run2.id);
+}
+async function settledReview(repo, run2, deps) {
+  for (; ; ) {
+    const { jobs } = jobsSchema2.parse(await deps.get(`repos/${repo}/actions/runs/${run2}/jobs`));
+    const review2 = jobs.find((job) => job.name.endsWith(" / review"));
+    if (!review2 || review2.conclusion === "skipped") return void 0;
+    if (review2.status === "completed") return review2.conclusion ?? "unknown";
+    deps.log(`Waiting for the review in run ${run2} to finish (${review2.status})`);
+    await deps.sleep(pollInterval);
+  }
+}
+async function forkVerdict({ repo, event }, deps) {
+  const { sha } = event.pull_request.head;
+  const statuses = statusesSchema2.parse(await deps.get(`repos/${repo}/commits/${sha}/statuses?per_page=100`));
+  const approved = statuses.find((status) => status.context === approvedReviewContext);
+  if (!approved) return { pass: false, message: forkHint };
+  const where = approved.target_url ? `, in ${approved.target_url},` : "";
+  const message = `The review a maintainer approved for ${sha.slice(0, 7)}${where} ${approved.description ?? `finished with ${approved.state}`}.`;
+  if (approved.state === "pending") return { pass: false, message: `${message} The gate re-runs when it finishes.` };
+  return approved.state === "success" ? { pass: true, message } : { pass: false, message: `${message} ${forkRerunHint}` };
+}
+async function reviewGate(reviewResult, context, deps) {
+  if (context.eventName === "pull_request_target") return handOffApprovedReview(reviewResult, context, deps);
+  if (reviewResult !== "skipped") return verdict(reviewResult, `The review on this event finished with ${reviewResult}.`);
+  const { pull_request } = context.event;
+  if (pull_request.user.type === "Bot") return verdict("success", "No review runs for PRs from bots.");
+  if (pull_request.head.repo?.full_name !== context.repo) return forkVerdict(context, deps);
+  for (const run2 of await earlierRuns(context, deps)) {
+    const conclusion = await settledReview(context.repo, run2, deps);
+    const url = `${context.serverUrl}/${context.repo}/actions/runs/${run2}`;
+    if (conclusion) return verdict(conclusion, `The latest review for this PR, in run ${url}, finished with ${conclusion}.`);
+  }
+  return { pass: false, message: `No review has completed for this PR yet. ${firstRunHint}` };
+}
+async function runReviewGate(reviewResult, out, env = process.env) {
+  const deps = { get: (path) => githubGet(path), post: githubPost, sleep: (ms) => setTimeout(ms), log: out };
+  const { pass, message } = await reviewGate(reviewResult, gateContext(env), deps);
+  out(pass ? message : `::error::${message}`);
+  if (env.GITHUB_STEP_SUMMARY) appendFileSync3(env.GITHUB_STEP_SUMMARY, `${message}
+`);
+  return pass;
+}
+
+// src/features/review/unapprove.ts
+function isNotFound(error) {
+  return error instanceof Error && error.message.includes("(HTTP 404)");
+}
+async function unapproveReview({ repo, eventName, event }, remove) {
+  const { number, head, labels } = event.pull_request;
+  if (eventName !== "pull_request_target" || event.action !== "synchronize")
+    return "Only a push to a fork PR, on pull_request_target, removes its approval.";
+  if (head.repo?.full_name === repo) return `#${number} is not from a fork, so it has no approval to remove.`;
+  if (!labels?.some((label) => label.name === reviewLabel)) return `#${number} has no \`${reviewLabel}\` label to remove.`;
+  try {
+    await remove(`repos/${repo}/issues/${number}/labels/${reviewLabel}`);
+  } catch (error) {
+    if (!isNotFound(error)) throw error;
+    return `#${number} no longer has the \`${reviewLabel}\` label; it was already removed.`;
+  }
+  return `Removed the \`${reviewLabel}\` label from #${number} after a push to ${head.sha.slice(0, 7)}. A maintainer must read the new commits, then add it again to review them.`;
+}
+async function runUnapproveReview(out, env = process.env) {
+  out(await unapproveReview(gateContext(env, "yoke review unapprove"), (path) => githubDelete(path)));
+}
+
+// src/reviewCiCommands.ts
+var ciKeys = settingKeys.filter((key) => /^review\.\w+\.(harness|model)$/.test(key));
+function fail(error, ...expected) {
+  if (!expected.some((type) => error instanceof type) || !(error instanceof Error)) throw error;
+  console.error(error.message);
+  process.exitCode = 1;
+}
+var resultHelp = "result of the review job on this event: success, failure, cancelled or skipped; pending marks an approved review as running";
+async function gate(result) {
   try {
     if (!await runReviewGate(result, console.log)) process.exitCode = 1;
   } catch (error) {
-    if (!(error instanceof ReviewError)) throw error;
+    fail(error, ReviewError);
+  }
+}
+async function unapprove() {
+  try {
+    await runUnapproveReview(console.log);
+  } catch (error) {
+    fail(error, ReviewError);
+  }
+}
+function addReviewCiCommands(review2) {
+  addSettingOptions(
+    review2.command("ci").description(
+      `Write ${callerWorkflowPath} so each PR in this repo is reviewed in CI, then print the secrets, or Entra federated credential, it needs`
+    ).option("--provider <provider>", "litellm or foundry; every slot uses it in CI. Default: review.reviewer1.provider, else litellm").option(
+      "--azure-client-id <id>",
+      "Entra app (client) ID to sign in to Foundry with GitHub OIDC instead of an API key; needs --provider foundry"
+    ).option("--azure-tenant-id <id>", "Entra tenant ID of that app").option("--environment <name>", "GitHub environment the review job runs in, matching the app's federated credential subject").option("--print", `print the workflow and setup commands without writing ${callerWorkflowPath}`),
+    ciKeys
+  ).addHelpText("after", settingsHelp).action((options) => {
+    try {
+      const settings = resolveSettings(flagSettings(options, ciKeys), process.env, readUserConfig(userConfigPath()));
+      const workflow = callerWorkflow(settings, options.provider, options);
+      const root = repoRoot();
+      const outcome = options.print ? "printed" : writeCallerWorkflow(root, renderCallerWorkflow(workflow));
+      console.log(reviewCiReport(outcome, settings, workflow, () => githubRepo(root)));
+    } catch (error) {
+      fail(error, ReviewError, ConfigError);
+    }
+  });
+  review2.command("ci-gate").description(`Require the ${gateCheck} check on the default branch with a ruleset, once the CI review workflow is merged`).action(async () => {
+    try {
+      console.log((await enforceReviewGate()).message);
+    } catch (error) {
+      fail(error, ReviewError);
+    }
+  });
+  review2.command("gate").description(
+    "Block merging until the latest review that ran for the PR succeeds, or for a fork PR, a review approved by a user with write access adding the `review` label; bot PRs pass. On pull_request_target, records the approved review on the PR head and re-runs its gate. Used by review.yml's review and gate jobs"
+  ).argument("<result>", resultHelp).action(gate);
+  review2.command("unapprove").description(
+    "Remove the `review` label from a fork PR after a push, so a maintainer reads the new commits before they are reviewed. Used by review.yml's unapprove job on pull_request_target"
+  ).action(unapprove);
+}
+function addLockedWorkflowAliases(program2) {
+  program2.command("review-gate", { hidden: true }).argument("<result>", resultHelp).action(gate);
+  program2.command("review-unapprove", { hidden: true }).action(unapprove);
+}
+
+// src/cli.ts
+var { version } = package_default;
+var program = new Command("yoke").description("Lean Claude Code skills and the CLI they call.").version(version).enablePositionalOptions();
+program.command("sync").description("Write yoke's skills into this repo's .claude/skills, or ~/.claude/skills with --user").option("--user", "write to ~/.claude/skills instead, for every repo").option("--force", "overwrite same-named skills that yoke didn't write").action((options) => {
+  const user = options.user ?? false;
+  const cwd = process.cwd();
+  const display = (path) => path.startsWith(cwd) ? relative2(cwd, path) : path;
+  const { written, skipped } = syncSkills(skillsRoot(user), skillsRoot(true), options.force ?? false);
+  for (const file of written) console.log(`wrote ${display(file)}`);
+  for (const dir of skipped) console.log(`skipped ${display(dir)} (not yoke's skill; rerun with --force to overwrite it)`);
+});
+program.command("update").description("Update yoke to the latest version, then re-sync its skills wherever they were synced before").action(() => {
+  const dir = installDir();
+  process.exitCode = updateYoke({
+    dir,
+    install: detectInstall(dir),
+    targets: () => syncTargets(),
+    log: console.log,
+    error: console.error
+  });
+});
+var pr = program.command("pr").description("Pull request commands");
+pr.command("raise").description("Validate a PR title and body, then create the PR with gh").requiredOption("--title <title>", "single-line PR title").requiredOption("--body <body>", "PR body with ## What, ## Why and optionally ## How").option("--base <branch>", "base branch (defaults to the repo default)").option("--no-draft", "create a ready-for-review PR instead of a draft").addHelpText("after", raiseGuide).action((options) => {
+  try {
+    console.log(raisePr(options));
+  } catch (error) {
+    if (!(error instanceof PrValidationError)) throw error;
     console.error(error.message);
     process.exitCode = 1;
   }
 });
+var providerKeys = settingKeys.filter((key) => !key.startsWith("review."));
+var review = addSettingOptions(
+  program.command("review").description("Review the current branch's PR, or PR <number>, with Claude and Codex in parallel, then combine their findings").argument("[number]", "PR number; reviewed without checking it out").option("--post", "post the findings to the PR as one review, reusing the saved review of the PR head when there is one").option("--force", "discard this PR head's cached reviews and run every pass again").option("--verbose", "print every step and each reviewer's tool calls as log lines instead of live spinners").option("--head <sha>", "refuse to review unless the PR's head is this commit; empty skips the check"),
+  settingKeys
+).addHelpText("after", settingsHelp).action(
+  async (number, options) => {
+    const verbose = options.verbose ?? false;
+    const ui = process.stderr.isTTY && !verbose ? spinnerUi(process.stderr) : lineUi(console.error, { activity: verbose });
+    try {
+      const settings = resolveSettings(flagSettings(options, settingKeys), process.env, readUserConfig(userConfigPath()));
+      const run2 = { post: options.post ?? false, force: options.force ?? false, head: options.head };
+      await reviewPr(number, settings, run2, { out: console.log, ui });
+    } catch (error) {
+      if (!(error instanceof ReviewError || error instanceof ConfigError)) throw error;
+      console.error(error.message);
+      process.exitCode = 1;
+    } finally {
+      ui.stop();
+    }
+  }
+);
+addReviewCiCommands(review);
+addLockedWorkflowAliases(program);
 addSettingOptions(
   program.command("models").description("List the models each configured provider serves, for review.*.provider and review.*.model"),
   providerKeys