@ghx-dev/core 0.1.0 → 0.1.2

package/dist/chunk-RDUPMVHG.js

@@ -0,0 +1,4139 @@
+import {
+  ajv,
+  getOperationCard
+} from "./chunk-UN5YHUNK.js";
+
+// src/core/execution/cli/safe-runner.ts
+import { spawn } from "child_process";
+var DEFAULT_MAX_OUTPUT_BYTES = 1e6;
+function createSafeCliCommandRunner(options) {
+  const maxOutputBytes = options?.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+  return {
+    run(command, args, timeoutMs) {
+      if (timeoutMs <= 0) {
+        return Promise.reject(new Error("timeoutMs must be a positive number"));
+      }
+      return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+          shell: false,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let stdoutSize = 0;
+        let stderrSize = 0;
+        let failureReason = null;
+        let settled = false;
+        const timer = setTimeout(() => {
+          if (failureReason === null) {
+            failureReason = "timeout";
+          }
+          child.kill("SIGKILL");
+        }, timeoutMs);
+        function settleError(error) {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          clearTimeout(timer);
+          reject(error);
+        }
+        function settleSuccess(stdout, stderr, exitCode) {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          clearTimeout(timer);
+          resolve({ stdout, stderr, exitCode });
+        }
+        child.stdout?.on("data", (chunk) => {
+          if (failureReason === "overflow") {
+            return;
+          }
+          stdoutSize += chunk.length;
+          if (stdoutSize + stderrSize > maxOutputBytes) {
+            if (failureReason === null) {
+              failureReason = "overflow";
+              clearTimeout(timer);
+              child.kill("SIGKILL");
+              settleError(new Error(`CLI output exceeded ${maxOutputBytes} bytes`));
+              return;
+            }
+            child.kill("SIGKILL");
+            return;
+          }
+          stdoutChunks.push(chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+          if (failureReason === "overflow") {
+            return;
+          }
+          stderrSize += chunk.length;
+          if (stdoutSize + stderrSize > maxOutputBytes) {
+            if (failureReason === null) {
+              failureReason = "overflow";
+              clearTimeout(timer);
+              child.kill("SIGKILL");
+              settleError(new Error(`CLI output exceeded ${maxOutputBytes} bytes`));
+              return;
+            }
+            child.kill("SIGKILL");
+            return;
+          }
+          stderrChunks.push(chunk);
+        });
+        child.on("error", (error) => {
+          settleError(error);
+        });
+        child.on("close", (code) => {
+          if (failureReason === "timeout") {
+            settleError(new Error(`CLI command timed out after ${timeoutMs}ms`));
+            return;
+          }
+          if (failureReason === "overflow") {
+            settleError(new Error(`CLI output exceeded ${maxOutputBytes} bytes`));
+            return;
+          }
+          settleSuccess(
+            Buffer.concat(stdoutChunks).toString("utf8"),
+            Buffer.concat(stderrChunks).toString("utf8"),
+            code ?? 1
+          );
+        });
+      });
+    }
+  };
+}
+
+// src/core/errors/codes.ts
+var errorCodes = {
+  Auth: "AUTH",
+  NotFound: "NOT_FOUND",
+  Validation: "VALIDATION",
+  RateLimit: "RATE_LIMIT",
+  Network: "NETWORK",
+  Server: "SERVER",
+  AdapterUnsupported: "ADAPTER_UNSUPPORTED",
+  Unknown: "UNKNOWN"
+};
+
+// src/core/execution/normalizer.ts
+function buildMeta(route, options) {
+  const meta = {
+    capability_id: options.capabilityId,
+    route_used: route
+  };
+  if (options.reason !== void 0) {
+    meta.reason = options.reason;
+  }
+  if (options.pagination !== void 0) {
+    meta.pagination = options.pagination;
+  }
+  return meta;
+}
+function normalizeResult(data, route, options) {
+  return {
+    ok: true,
+    data,
+    meta: buildMeta(route, options)
+  };
+}
+function normalizeError(error, route, options) {
+  return {
+    ok: false,
+    error,
+    meta: buildMeta(route, options)
+  };
+}
+
+// src/core/registry/schema-validator.ts
+var validatorCache = /* @__PURE__ */ new WeakMap();
+function mapAjvErrors(errors) {
+  if (!errors) {
+    return [];
+  }
+  return errors.map((error) => ({
+    instancePath: error.instancePath,
+    message: error.message ?? "schema validation failed",
+    keyword: error.keyword,
+    params: error.params
+  }));
+}
+function getValidator(schema) {
+  const cached = validatorCache.get(schema);
+  if (cached) {
+    return cached;
+  }
+  const validator = ajv.compile(schema);
+  validatorCache.set(schema, validator);
+  return validator;
+}
+function validate(schema, payload) {
+  const validator = getValidator(schema);
+  const ok = validator(payload);
+  if (ok) {
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    errors: mapAjvErrors(validator.errors)
+  };
+}
+function validateInput(inputSchema, params) {
+  return validate(inputSchema, params);
+}
+function validateOutput(outputSchema, data) {
+  return validate(outputSchema, data);
+}
+
+// src/core/telemetry/logger.ts
+var SENSITIVE_KEY_PATTERN = /(token|authorization|cookie|secret|password|api[_-]?key)/i;
+function redactValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(redactValue);
+  }
+  if (value && typeof value === "object") {
+    const redacted = {};
+    for (const [key, nested] of Object.entries(value)) {
+      redacted[key] = SENSITIVE_KEY_PATTERN.test(key) ? "[REDACTED]" : redactValue(nested);
+    }
+    return redacted;
+  }
+  return value;
+}
+function sanitizeTelemetryContext(context) {
+  return redactValue(context);
+}
+function logMetric(name, value, context = {}) {
+  if (process.env.GHX_TELEMETRY_STDOUT !== "1") {
+    return;
+  }
+  const payload = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    metric: name,
+    value,
+    context: sanitizeTelemetryContext(context)
+  };
+  process.stdout.write(`${JSON.stringify(payload)}
+`);
+}
+
+// src/core/execute/execute.ts
+function parsePredicateValue(raw) {
+  const value = raw.trim();
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  if (value === "null") {
+    return null;
+  }
+  const numeric = Number(value);
+  if (!Number.isNaN(numeric) && value.length > 0) {
+    return numeric;
+  }
+  return value.replace(/^['"]|['"]$/g, "");
+}
+function resolvePathValue(source, path) {
+  const segments = path.split(".").filter((segment) => segment.length > 0);
+  let current = source;
+  for (const segment of segments) {
+    if (typeof current !== "object" || current === null || Array.isArray(current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function evaluateSuitabilityPreferred(card, params, routingContext) {
+  const rules = card.routing.suitability ?? [];
+  for (const rule of rules) {
+    const alwaysMatch = /^(cli|graphql|rest)$/i.exec(rule.predicate.trim());
+    const alwaysRoute = alwaysMatch?.[1];
+    if (rule.when === "always" && alwaysRoute) {
+      return alwaysRoute.toLowerCase();
+    }
+    const conditionalMatch = /^(cli|graphql|rest)\s+if\s+([a-zA-Z0-9_.]+)\s*(==|!=)\s*(.+)$/i.exec(
+      rule.predicate.trim()
+    );
+    if (!conditionalMatch) {
+      continue;
+    }
+    const [, targetRouteRaw = "", rawPath = "", operator = "==", rawExpected = ""] = conditionalMatch;
+    const targetRoute = targetRouteRaw.toLowerCase();
+    const source = rule.when === "env" ? routingContext : params;
+    const path = rawPath.startsWith("params.") || rawPath.startsWith("env.") ? rawPath.split(".").slice(1).join(".") : rawPath;
+    const actual = resolvePathValue(source, path);
+    const expected = parsePredicateValue(rawExpected);
+    const matches = operator === "==" ? actual === expected : actual !== expected;
+    if (matches) {
+      return targetRoute;
+    }
+  }
+  return card.routing.preferred;
+}
+function routePlan(card, params, routingContext) {
+  const preferred = evaluateSuitabilityPreferred(card, params, routingContext);
+  const planned = /* @__PURE__ */ new Set([preferred, ...card.routing.fallbacks]);
+  return [...planned];
+}
+async function execute(options) {
+  const inputValidation = validateInput(options.card.input_schema, options.params);
+  if (!inputValidation.ok) {
+    return normalizeError(
+      {
+        code: errorCodes.Validation,
+        message: "Input schema validation failed",
+        retryable: false,
+        details: { ajvErrors: inputValidation.errors }
+      },
+      options.card.routing.preferred,
+      {
+        capabilityId: options.card.capability_id,
+        reason: "INPUT_VALIDATION"
+      }
+    );
+  }
+  const attempts = [];
+  const maxAttemptsPerRoute = Math.max(1, options.retry?.maxAttemptsPerRoute ?? 1);
+  let lastError;
+  let firstError;
+  const routingContext = options.routingContext ?? {};
+  for (const route of routePlan(options.card, options.params, routingContext)) {
+    logMetric("route.plan", 1, {
+      capability_id: options.card.capability_id,
+      route
+    });
+    const preflight = await options.preflight(route);
+    if (!preflight.ok) {
+      logMetric("route.preflight_skipped", 1, {
+        capability_id: options.card.capability_id,
+        route,
+        error_code: preflight.code
+      });
+      attempts.push({ route, status: "skipped", error_code: preflight.code });
+      lastError = {
+        code: preflight.code,
+        message: preflight.message,
+        retryable: preflight.retryable,
+        ...preflight.details ? { details: preflight.details } : {}
+      };
+      firstError ??= lastError;
+      continue;
+    }
+    const routeHandler = options.routes[route];
+    if (typeof routeHandler !== "function") {
+      logMetric("route.missing_handler", 1, {
+        capability_id: options.card.capability_id,
+        route
+      });
+      const handlerError = {
+        code: errorCodes.AdapterUnsupported,
+        message: `No route handler configured for '${route}'`,
+        retryable: false,
+        details: { route }
+      };
+      attempts.push({ route, status: "skipped", error_code: errorCodes.AdapterUnsupported });
+      lastError = handlerError;
+      firstError ??= handlerError;
+      continue;
+    }
+    for (let attempt = 0; attempt < maxAttemptsPerRoute; attempt += 1) {
+      const result = await routeHandler(options.params);
+      logMetric("route.attempt", 1, {
+        capability_id: options.card.capability_id,
+        route,
+        ok: result.ok
+      });
+      const attemptRecord = {
+        route,
+        status: result.ok ? "success" : "error"
+      };
+      if (result.error?.code) {
+        attemptRecord.error_code = result.error.code;
+      }
+      attempts.push(attemptRecord);
+      if (result.ok) {
+        const outputValidation = validateOutput(options.card.output_schema, result.data);
+        if (!outputValidation.ok) {
+          const envelope2 = normalizeError(
+            {
+              code: errorCodes.Server,
+              message: "Output schema validation failed",
+              retryable: false,
+              details: { ajvErrors: outputValidation.errors }
+            },
+            route,
+            {
+              capabilityId: options.card.capability_id,
+              reason: "OUTPUT_VALIDATION"
+            }
+          );
+          if (options.trace) {
+            envelope2.meta.attempts = attempts;
+          }
+          return envelope2;
+        }
+        if (options.trace) {
+          result.meta.attempts = attempts;
+        }
+        return result;
+      }
+      lastError = result.error;
+      firstError ??= result.error;
+      if (!result.error?.retryable) {
+        if (result.error?.code !== errorCodes.AdapterUnsupported) {
+          if (options.trace) {
+            result.meta.attempts = attempts;
+          }
+          return result;
+        }
+        break;
+      }
+    }
+  }
+  const finalError = lastError ?? firstError ?? {
+    code: errorCodes.Unknown,
+    message: "No route produced a result",
+    retryable: false
+  };
+  const envelope = normalizeError(finalError, options.card.routing.preferred, {
+    capabilityId: options.card.capability_id,
+    reason: "CARD_FALLBACK"
+  });
+  if (options.trace) {
+    envelope.meta.attempts = attempts;
+  }
+  return envelope;
+}
+
+// src/core/errors/map-error.ts
+function toMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function mapErrorToCode(error) {
+  const message = toMessage(error).toLowerCase();
+  if (message.includes("rate limit") || /\b429\b/.test(message) || message.includes("too many requests")) {
+    return errorCodes.RateLimit;
+  }
+  if (/\b(500|502|503|504)\b/.test(message)) {
+    return errorCodes.Server;
+  }
+  if (message.includes("timeout")) {
+    return errorCodes.Network;
+  }
+  if (message.includes("econn") || message.includes("enotfound") || message.includes("eai_again") || message.includes("network") || message.includes("connection reset")) {
+    return errorCodes.Network;
+  }
+  if (message.includes("not found") || /\b404\b/.test(message)) {
+    return errorCodes.NotFound;
+  }
+  if (message.includes("auth") || message.includes("forbidden") || message.includes("unauthorized")) {
+    return errorCodes.Auth;
+  }
+  if (message.includes("validation") || message.includes("invalid") || message.includes("required") || message.includes("positive integer")) {
+    return errorCodes.Validation;
+  }
+  return errorCodes.Unknown;
+}
+
+// src/core/errors/retryability.ts
+var retryableCodes = /* @__PURE__ */ new Set([
+  errorCodes.Network,
+  errorCodes.RateLimit,
+  errorCodes.Server
+]);
+function isRetryableErrorCode(code) {
+  return retryableCodes.has(code);
+}
+
+// src/core/execution/adapters/cli-capability-adapter.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_LIST_FIRST = 30;
+var MAX_WORKFLOW_JOB_LOG_CHARS = 5e4;
+var REDACTED_CLI_ERROR_MESSAGE = "gh command failed; stderr redacted for safety";
+var NON_JSON_STDOUT_CAPABILITIES = /* @__PURE__ */ new Set([
+  "pr.checks.rerun_failed",
+  "pr.checks.rerun_all",
+  "pr.reviewers.request",
+  "pr.assignees.update",
+  "pr.branch.update",
+  "workflow_run.cancel",
+  "workflow_run.rerun_failed",
+  "workflow_run.rerun_all"
+]);
+var REPO_ISSUE_TYPES_GRAPHQL_QUERY = "query($owner:String!,$name:String!,$first:Int!,$after:String){repository(owner:$owner,name:$name){issueTypes(first:$first,after:$after){nodes{id name color isEnabled} pageInfo{hasNextPage endCursor}}}}";
+var ISSUE_COMMENTS_GRAPHQL_QUERY = "query($owner:String!,$name:String!,$issueNumber:Int!,$first:Int!,$after:String){repository(owner:$owner,name:$name){issue(number:$issueNumber){comments(first:$first,after:$after){nodes{id body createdAt url author{login}} pageInfo{hasNextPage endCursor}}}}}";
+function containsSensitiveText(value) {
+  return /(gh[pousr]_[A-Za-z0-9_]+|github_pat_[A-Za-z0-9_]+|authorization:\s*bearer\s+\S+|bearer\s+[A-Za-z0-9._-]{20,}|(?:api[_-]?key|token|secret|password)\s*[=:]\s*\S+)/i.test(
+    value
+  );
+}
+function sanitizeCliErrorMessage(stderr, exitCode) {
+  const trimmed = stderr.trim();
+  if (!trimmed) {
+    return `gh exited with code ${exitCode}`;
+  }
+  if (containsSensitiveText(trimmed)) {
+    return REDACTED_CLI_ERROR_MESSAGE;
+  }
+  return trimmed;
+}
+function shouldFallbackRerunFailedToAll(stderr) {
+  const normalized = stderr.toLowerCase();
+  return normalized.includes("cannot be rerun") && normalized.includes("cannot be retried");
+}
+function parseStrictPositiveInt(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : null;
+}
+function parseListFirst(value) {
+  if (value === void 0) {
+    return DEFAULT_LIST_FIRST;
+  }
+  return parseStrictPositiveInt(value);
+}
+function parseNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function requireRepo(owner, name, capabilityId) {
+  if (!owner || !name) {
+    throw new Error(`Missing owner/name for ${capabilityId}`);
+  }
+}
+function commandTokens(card, fallbackCommand) {
+  const fromCard = card?.cli?.command;
+  const command = typeof fromCard === "string" && fromCard.trim().length > 0 ? fromCard : fallbackCommand;
+  return command.trim().split(/\s+/);
+}
+function jsonFieldsFromCard(card, fallbackFields) {
+  const fields = card?.cli?.jsonFields;
+  if (Array.isArray(fields) && fields.length > 0) {
+    return fields.join(",");
+  }
+  return fallbackFields;
+}
+function buildArgs(capabilityId, params, card) {
+  const owner = String(params.owner ?? "");
+  const name = String(params.name ?? "");
+  const repo = owner && name ? `${owner}/${name}` : "";
+  if (capabilityId === "repo.view") {
+    const args = commandTokens(card, "repo view");
+    if (repo) {
+      args.push(repo);
+    }
+    args.push(
+      "--json",
+      jsonFieldsFromCard(
+        card,
+        "id,name,nameWithOwner,isPrivate,stargazerCount,forkCount,url,defaultBranchRef"
+      )
+    );
+    return args;
+  }
+  if (capabilityId === "repo.labels.list") {
+    const first = parseListFirst(params.first);
+    if (first === null) {
+      throw new Error("Missing or invalid first for repo.labels.list");
+    }
+    const args = commandTokens(card, "label list");
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push(
+      "--limit",
+      String(first),
+      "--json",
+      jsonFieldsFromCard(card, "id,name,description,color,isDefault")
+    );
+    return args;
+  }
+  if (capabilityId === "repo.issue_types.list") {
+    const first = parseListFirst(params.first);
+    if (first === null) {
+      throw new Error("Missing or invalid first for repo.issue_types.list");
+    }
+    const after = params.after;
+    if (!(after === void 0 || after === null || typeof after === "string")) {
+      throw new Error("Invalid after cursor for repo.issue_types.list");
+    }
+    if (!owner || !name) {
+      throw new Error("Missing owner/name for repo.issue_types.list");
+    }
+    const args = [
+      ...commandTokens(card, "api graphql"),
+      "-f",
+      `query=${REPO_ISSUE_TYPES_GRAPHQL_QUERY}`,
+      "-f",
+      `owner=${owner}`,
+      "-f",
+      `name=${name}`,
+      "-F",
+      `first=${first}`
+    ];
+    if (typeof after === "string" && after.length > 0) {
+      args.push("-f", `after=${after}`);
+    }
+    return args;
+  }
+  if (capabilityId === "issue.view") {
+    const issueNumber = parseStrictPositiveInt(params.issueNumber);
+    if (issueNumber === null) {
+      throw new Error("Missing or invalid issueNumber for issue.view");
+    }
+    const args = [...commandTokens(card, "issue view"), String(issueNumber)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push("--json", jsonFieldsFromCard(card, "id,number,title,state,url"));
+    return args;
+  }
+  if (capabilityId === "issue.list") {
+    const first = parseListFirst(params.first);
+    if (first === null) {
+      throw new Error("Missing or invalid first for issue.list");
+    }
+    const args = commandTokens(card, "issue list");
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push(
+      "--limit",
+      String(first),
+      "--json",
+      jsonFieldsFromCard(card, "id,number,title,state,url")
+    );
+    return args;
+  }
+  if (capabilityId === "issue.comments.list") {
+    const issueNumber = parseStrictPositiveInt(params.issueNumber);
+    if (issueNumber === null) {
+      throw new Error("Missing or invalid issueNumber for issue.comments.list");
+    }
+    const first = parseStrictPositiveInt(params.first);
+    if (first === null) {
+      throw new Error("Missing or invalid first for issue.comments.list");
+    }
+    const after = params.after;
+    if (!(after === void 0 || after === null || typeof after === "string")) {
+      throw new Error("Invalid after cursor for issue.comments.list");
+    }
+    const args = [
+      ...commandTokens(card, "api graphql"),
+      "-f",
+      `query=${ISSUE_COMMENTS_GRAPHQL_QUERY}`,
+      "-f",
+      `owner=${owner}`,
+      "-f",
+      `name=${name}`,
+      "-F",
+      `issueNumber=${issueNumber}`,
+      "-F",
+      `first=${first}`
+    ];
+    if (typeof after === "string" && after.length > 0) {
+      args.push("-f", `after=${after}`);
+    }
+    return args;
+  }
+  if (capabilityId === "pr.view") {
+    const prNumber = parseStrictPositiveInt(params.prNumber);
+    if (prNumber === null) {
+      throw new Error("Missing or invalid prNumber for pr.view");
+    }
+    const args = [...commandTokens(card, "pr view"), String(prNumber)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push("--json", jsonFieldsFromCard(card, "id,number,title,state,url"));
+    return args;
+  }
+  if (capabilityId === "pr.list") {
+    const first = parseListFirst(params.first);
+    if (first === null) {
+      throw new Error("Missing or invalid first for pr.list");
+    }
+    const args = commandTokens(card, "pr list");
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push(
+      "--limit",
+      String(first),
+      "--json",
+      jsonFieldsFromCard(card, "id,number,title,state,url")
+    );
+    return args;
+  }
+  if (capabilityId === "pr.status.checks" || capabilityId === "pr.checks.get_failed") {
+    const prNumber = parseStrictPositiveInt(params.prNumber);
+    if (prNumber === null) {
+      throw new Error(`Missing or invalid prNumber for ${capabilityId}`);
+    }
+    const args = [...commandTokens(card, "pr checks"), String(prNumber)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push("--json", jsonFieldsFromCard(card, "name,state,bucket,workflow,link"));
+    return args;
+  }
+  if (capabilityId === "pr.mergeability.view") {
+    const prNumber = parseStrictPositiveInt(params.prNumber);
+    if (prNumber === null) {
+      throw new Error("Missing or invalid prNumber for pr.mergeability.view");
+    }
+    const args = [...commandTokens(card, "pr view"), String(prNumber)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push(
+      "--json",
+      jsonFieldsFromCard(card, "mergeable,mergeStateStatus,reviewDecision,isDraft,state")
+    );
+    return args;
+  }
+  if (capabilityId === "pr.ready_for_review.set") {
+    const prNumber = parseStrictPositiveInt(params.prNumber);
+    if (prNumber === null) {
+      throw new Error("Missing or invalid prNumber for pr.ready_for_review.set");
+    }
+    if (typeof params.ready !== "boolean") {
+      throw new Error("Missing or invalid ready for pr.ready_for_review.set");
+    }
+    const args = [...commandTokens(card, "pr ready"), String(prNumber)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    if (!params.ready) {
+      args.push("--undo");
+    }
+    return args;
+  }
+  if (capabilityId === "pr.review.submit_approve" || capabilityId === "pr.review.submit_request_changes" || capabilityId === "pr.review.submit_comment") {
+    const prNumber = parseStrictPositiveInt(params.prNumber);
+    if (prNumber === null) {
+      throw new Error(`Missing or invalid prNumber for ${capabilityId}`);
+    }
+    const args = [...commandTokens(card, "pr review"), String(prNumber)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    if (capabilityId === "pr.review.submit_approve") {
+      args.push("--approve");
+      const body2 = parseNonEmptyString(params.body);
+      if (body2) {
+        args.push("--body", body2);
+      }
+      return args;
+    }
+    const body = parseNonEmptyString(params.body);
+    if (body === null) {
+      throw new Error(`Missing or invalid body for ${capabilityId}`);
+    }
+    if (capabilityId === "pr.review.submit_request_changes") {
+      args.push("--request-changes", "--body", body);
+      return args;
+    }
+    args.push("--comment", "--body", body);
+    return args;
+  }
+  if (capabilityId === "pr.merge.execute") {
+    const prNumber = parseStrictPositiveInt(params.prNumber);
+    if (prNumber === null) {
+      throw new Error("Missing or invalid prNumber for pr.merge.execute");
+    }
+    const method = params.method === void 0 ? "merge" : params.method;
+    if (method !== "merge" && method !== "squash" && method !== "rebase") {
+      throw new Error("Missing or invalid method for pr.merge.execute");
+    }
+    if (params.deleteBranch !== void 0 && typeof params.deleteBranch !== "boolean") {
+      throw new Error("Missing or invalid deleteBranch for pr.merge.execute");
+    }
+    const args = [...commandTokens(card, "pr merge"), String(prNumber)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push(`--${method}`);
+    if (params.deleteBranch === true) {
+      args.push("--delete-branch");
+    }
+    return args;
+  }
+  if (capabilityId === "pr.checks.rerun_failed" || capabilityId === "pr.checks.rerun_all") {
+    const prNumber = parseStrictPositiveInt(params.prNumber);
+    if (prNumber === null) {
+      throw new Error(`Missing or invalid prNumber for ${capabilityId}`);
+    }
+    const runId = parseStrictPositiveInt(params.runId);
+    if (runId === null) {
+      throw new Error(`Missing or invalid runId for ${capabilityId}`);
+    }
+    const args = [...commandTokens(card, "run rerun"), String(runId)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    if (capabilityId === "pr.checks.rerun_failed") {
+      args.push("--failed");
+    }
+    return args;
+  }
+  if (capabilityId === "pr.reviewers.request") {
+    const prNumber = parseStrictPositiveInt(params.prNumber);
+    if (prNumber === null) {
+      throw new Error("Missing or invalid prNumber for pr.reviewers.request");
+    }
+    const reviewers = Array.isArray(params.reviewers) ? params.reviewers.filter(
+      (value) => typeof value === "string" && value.trim().length > 0
+    ) : [];
+    if (reviewers.length === 0) {
+      throw new Error("Missing or invalid reviewers for pr.reviewers.request");
+    }
+    const args = [...commandTokens(card, "pr edit"), String(prNumber)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push("--add-reviewer", reviewers.join(","));
+    return args;
+  }
+  if (capabilityId === "pr.assignees.update") {
+    const prNumber = parseStrictPositiveInt(params.prNumber);
+    if (prNumber === null) {
+      throw new Error("Missing or invalid prNumber for pr.assignees.update");
+    }
+    const addAssignees = Array.isArray(params.add) ? params.add.filter(
+      (value) => typeof value === "string" && value.trim().length > 0
+    ) : [];
+    const removeAssignees = Array.isArray(params.remove) ? params.remove.filter(
+      (value) => typeof value === "string" && value.trim().length > 0
+    ) : [];
+    if (addAssignees.length === 0 && removeAssignees.length === 0) {
+      throw new Error("Missing or invalid add/remove assignees for pr.assignees.update");
+    }
+    const args = [...commandTokens(card, "pr edit"), String(prNumber)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    if (addAssignees.length > 0) {
+      args.push("--add-assignee", addAssignees.join(","));
+    }
+    if (removeAssignees.length > 0) {
+      args.push("--remove-assignee", removeAssignees.join(","));
+    }
+    return args;
+  }
+  if (capabilityId === "pr.branch.update") {
+    const prNumber = parseStrictPositiveInt(params.prNumber);
+    if (prNumber === null) {
+      throw new Error("Missing or invalid prNumber for pr.branch.update");
+    }
+    const args = [...commandTokens(card, "pr update-branch"), String(prNumber)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    return args;
+  }
+  if (capabilityId === "check_run.annotations.list") {
+    const checkRunId = parseStrictPositiveInt(params.checkRunId);
+    if (checkRunId === null) {
+      throw new Error("Missing or invalid checkRunId for check_run.annotations.list");
+    }
+    if (!owner || !name) {
+      throw new Error("Missing owner/name for check_run.annotations.list");
+    }
+    const args = [
+      ...commandTokens(card, "api"),
+      `repos/${owner}/${name}/check-runs/${checkRunId}/annotations`
+    ];
+    return args;
+  }
+  if (capabilityId === "workflow_runs.list") {
+    const first = parseListFirst(params.first);
+    if (first === null) {
+      throw new Error("Missing or invalid first for workflow_runs.list");
+    }
+    const args = commandTokens(card, "run list");
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    if (typeof params.branch === "string" && params.branch.length > 0) {
+      args.push("--branch", params.branch);
+    }
+    if (typeof params.event === "string" && params.event.length > 0) {
+      args.push("--event", params.event);
+    }
+    if (typeof params.status === "string" && params.status.length > 0) {
+      args.push("--status", params.status);
+    }
+    args.push(
+      "--limit",
+      String(first),
+      "--json",
+      jsonFieldsFromCard(card, "databaseId,workflowName,status,conclusion,headBranch,url")
+    );
+    return args;
+  }
+  if (capabilityId === "workflow_run.jobs.list") {
+    const runId = parseStrictPositiveInt(params.runId);
+    if (runId === null) {
+      throw new Error("Missing or invalid runId for workflow_run.jobs.list");
+    }
+    const args = [...commandTokens(card, "run view"), String(runId)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push("--json", "jobs");
+    return args;
+  }
+  if (capabilityId === "workflow_job.logs.get" || capabilityId === "workflow_job.logs.analyze") {
+    const jobId = parseStrictPositiveInt(params.jobId);
+    if (jobId === null) {
+      throw new Error(`Missing or invalid jobId for ${capabilityId}`);
+    }
+    const args = [...commandTokens(card, "run view"), "--job", String(jobId), "--log"];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    return args;
+  }
+  if (capabilityId === "workflow.list") {
+    const first = parseListFirst(params.first);
+    if (first === null) {
+      throw new Error("Missing or invalid first for workflow.list");
+    }
+    const args = commandTokens(card, "workflow list");
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push("--limit", String(first), "--json", jsonFieldsFromCard(card, "id,name,path,state"));
+    return args;
+  }
+  if (capabilityId === "workflow.get") {
+    const workflowId = parseNonEmptyString(params.workflowId) ?? (typeof params.workflowId === "number" ? String(params.workflowId) : null);
+    if (workflowId === null) {
+      throw new Error("Missing or invalid workflowId for workflow.get");
+    }
+    const args = [...commandTokens(card, "workflow view"), workflowId];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push("--json", jsonFieldsFromCard(card, "id,name,path,state,url"));
+    return args;
+  }
+  if (capabilityId === "workflow_run.get") {
+    const runId = parseStrictPositiveInt(params.runId);
+    if (runId === null) {
+      throw new Error("Missing or invalid runId for workflow_run.get");
+    }
+    const args = [...commandTokens(card, "run view"), String(runId)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push(
+      "--json",
+      jsonFieldsFromCard(
+        card,
+        "databaseId,workflowName,status,conclusion,headBranch,headSha,url,event,createdAt,updatedAt,startedAt"
+      )
+    );
+    return args;
+  }
+  if (capabilityId === "workflow_run.rerun_all" || capabilityId === "workflow_run.cancel") {
+    const runId = parseStrictPositiveInt(params.runId);
+    if (runId === null) {
+      throw new Error(`Missing or invalid runId for ${capabilityId}`);
+    }
+    const args = [
+      ...commandTokens(
+        card,
+        capabilityId === "workflow_run.rerun_all" ? "run rerun" : "run cancel"
+      ),
+      String(runId)
+    ];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    return args;
+  }
+  if (capabilityId === "workflow_run.artifacts.list") {
+    const runId = parseStrictPositiveInt(params.runId);
+    if (runId === null) {
+      throw new Error("Missing or invalid runId for workflow_run.artifacts.list");
+    }
+    const args = [...commandTokens(card, "run view"), String(runId)];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    args.push("--json", jsonFieldsFromCard(card, "artifacts"));
+    return args;
+  }
+  if (capabilityId === "project_v2.org.get" || capabilityId === "project_v2.user.get") {
+    const ownerParam = capabilityId === "project_v2.org.get" ? params.org : params.user;
+    const owner2 = parseNonEmptyString(ownerParam);
+    const projectNumber = parseStrictPositiveInt(params.projectNumber);
+    if (owner2 === null || projectNumber === null) {
+      throw new Error(`Missing or invalid owner/projectNumber for ${capabilityId}`);
+    }
+    const args = [
+      ...commandTokens(card, "project view"),
+      String(projectNumber),
+      "--owner",
+      owner2,
+      "--format",
+      "json"
+    ];
+    return args;
+  }
+  if (capabilityId === "project_v2.fields.list") {
+    const projectNumber = parseStrictPositiveInt(params.projectNumber);
+    const projectOwner = parseNonEmptyString(params.owner);
+    if (projectNumber === null || projectOwner === null) {
+      throw new Error("Missing or invalid owner/projectNumber for project_v2.fields.list");
+    }
+    const args = [
+      ...commandTokens(card, "project field-list"),
+      String(projectNumber),
+      "--owner",
+      projectOwner,
+      "--format",
+      "json"
+    ];
+    return args;
+  }
+  if (capabilityId === "project_v2.items.list") {
+    const projectNumber = parseStrictPositiveInt(params.projectNumber);
+    const projectOwner = parseNonEmptyString(params.owner);
+    const first = parseListFirst(params.first);
+    if (projectNumber === null || projectOwner === null || first === null) {
+      throw new Error("Missing or invalid owner/projectNumber/first for project_v2.items.list");
+    }
+    const args = [
+      ...commandTokens(card, "project item-list"),
+      String(projectNumber),
+      "--owner",
+      projectOwner,
+      "--format",
+      "json",
+      "--limit",
+      String(first)
+    ];
+    return args;
+  }
+  if (capabilityId === "release.list") {
+    requireRepo(owner, name, capabilityId);
+    const first = parseListFirst(params.first);
+    if (first === null) {
+      throw new Error("Missing or invalid first for release.list");
+    }
+    const args = [
+      ...commandTokens(card, "api"),
+      `repos/${owner}/${name}/releases`,
+      "-F",
+      `per_page=${first}`
+    ];
+    return args;
+  }
+  if (capabilityId === "release.get") {
+    requireRepo(owner, name, capabilityId);
+    const tagName = parseNonEmptyString(params.tagName);
+    if (tagName === null) {
+      throw new Error("Missing or invalid tagName for release.get");
+    }
+    const args = [
+      ...commandTokens(card, "api"),
+      `repos/${owner}/${name}/releases/tags/${encodeURIComponent(tagName)}`
+    ];
+    return args;
+  }
+  if (capabilityId === "release.create_draft") {
+    requireRepo(owner, name, capabilityId);
+    const tagName = parseNonEmptyString(params.tagName);
+    if (tagName === null) {
+      throw new Error("Missing or invalid tagName for release.create_draft");
+    }
+    const args = [
+      ...commandTokens(card, "api"),
+      `repos/${owner}/${name}/releases`,
+      "--method",
+      "POST",
+      "-f",
+      `tag_name=${tagName}`,
+      "-F",
+      "draft=true"
+    ];
+    const title = parseNonEmptyString(params.title);
+    if (title) {
+      args.push("-f", `name=${title}`);
+    }
+    const notes = parseNonEmptyString(params.notes);
+    if (notes) {
+      args.push("-f", `body=${notes}`);
+    }
+    const target = parseNonEmptyString(params.targetCommitish);
+    if (target) {
+      args.push("-f", `target_commitish=${target}`);
+    }
+    if (typeof params.prerelease === "boolean") {
+      args.push("-F", `prerelease=${params.prerelease ? "true" : "false"}`);
+    }
+    return args;
+  }
+  if (capabilityId === "release.update") {
+    requireRepo(owner, name, capabilityId);
+    const releaseId = parseStrictPositiveInt(params.releaseId);
+    if (releaseId === null) {
+      throw new Error("Missing or invalid releaseId for release.update");
+    }
+    if (params.draft !== void 0 && params.draft !== true) {
+      throw new Error(
+        "release.update only supports draft=true; use release.publish_draft to publish"
+      );
+    }
+    const args = [
+      ...commandTokens(card, "api"),
+      `repos/${owner}/${name}/releases/${releaseId}`,
+      "--method",
+      "PATCH",
+      "-F",
+      "draft=true"
+    ];
+    const tagName = parseNonEmptyString(params.tagName);
+    if (tagName) {
+      args.push("-f", `tag_name=${tagName}`);
+    }
+    const title = parseNonEmptyString(params.title);
+    if (title) {
+      args.push("-f", `name=${title}`);
+    }
+    const notes = parseNonEmptyString(params.notes);
+    if (notes) {
+      args.push("-f", `body=${notes}`);
+    }
+    const target = parseNonEmptyString(params.targetCommitish);
+    if (target) {
+      args.push("-f", `target_commitish=${target}`);
+    }
+    if (typeof params.prerelease === "boolean") {
+      args.push("-F", `prerelease=${params.prerelease ? "true" : "false"}`);
+    }
+    return args;
+  }
+  if (capabilityId === "release.publish_draft") {
+    requireRepo(owner, name, capabilityId);
+    const releaseId = parseStrictPositiveInt(params.releaseId);
+    if (releaseId === null) {
+      throw new Error("Missing or invalid releaseId for release.publish_draft");
+    }
+    const args = [
+      ...commandTokens(card, "api"),
+      `repos/${owner}/${name}/releases/${releaseId}`,
+      "--method",
+      "PATCH",
+      "-F",
+      "draft=false"
+    ];
+    const title = parseNonEmptyString(params.title);
+    if (title) {
+      args.push("-f", `name=${title}`);
+    }
+    const notes = parseNonEmptyString(params.notes);
+    if (notes) {
+      args.push("-f", `body=${notes}`);
+    }
+    if (typeof params.prerelease === "boolean") {
+      args.push("-F", `prerelease=${params.prerelease ? "true" : "false"}`);
+    }
+    return args;
+  }
+  if (capabilityId === "workflow_dispatch.run") {
+    requireRepo(owner, name, capabilityId);
+    const workflowId = parseNonEmptyString(params.workflowId);
+    if (workflowId === null) {
+      throw new Error("Missing or invalid workflowId for workflow_dispatch.run");
+    }
+    const ref = parseNonEmptyString(params.ref);
+    if (ref === null) {
+      throw new Error("Missing or invalid ref for workflow_dispatch.run");
+    }
+    const args = [
+      ...commandTokens(card, "api"),
+      `repos/${owner}/${name}/actions/workflows/${encodeURIComponent(workflowId)}/dispatches`,
+      "--method",
+      "POST",
+      "-f",
+      `ref=${ref}`
+    ];
+    if (params.inputs !== void 0) {
+      if (typeof params.inputs !== "object" || params.inputs === null || Array.isArray(params.inputs)) {
+        throw new Error("Missing or invalid inputs for workflow_dispatch.run");
+      }
+      const inputEntries = Object.entries(params.inputs);
+      for (const [key, value] of inputEntries) {
+        if (!key.trim()) {
+          throw new Error("Missing or invalid inputs for workflow_dispatch.run");
+        }
+        if (!(typeof value === "string" || typeof value === "number" || typeof value === "boolean")) {
+          throw new Error("Missing or invalid inputs for workflow_dispatch.run");
+        }
+        args.push("-f", `inputs[${key}]=${String(value)}`);
+      }
+    }
+    return args;
+  }
+  if (capabilityId === "workflow_run.rerun_failed") {
+    requireRepo(owner, name, capabilityId);
+    const runId = parseStrictPositiveInt(params.runId);
+    if (runId === null) {
+      throw new Error("Missing or invalid runId for workflow_run.rerun_failed");
+    }
+    const args = [
+      ...commandTokens(card, "api"),
+      `repos/${owner}/${name}/actions/runs/${runId}/rerun-failed-jobs`,
+      "--method",
+      "POST"
+    ];
+    return args;
+  }
+  if (capabilityId === "project_v2.item.add_issue") {
+    const projectNumber = parseStrictPositiveInt(params.projectNumber);
+    const projectOwner = parseNonEmptyString(params.owner);
+    const issueUrl = parseNonEmptyString(params.issueUrl);
+    if (projectNumber === null || projectOwner === null || issueUrl === null) {
+      throw new Error(
+        "Missing or invalid owner/projectNumber/issueUrl for project_v2.item.add_issue"
+      );
+    }
+    const args = [
+      ...commandTokens(card, "project item-add"),
+      String(projectNumber),
+      "--owner",
+      projectOwner,
+      "--url",
+      issueUrl,
+      "--format",
+      "json"
+    ];
+    return args;
+  }
+  if (capabilityId === "project_v2.item.field.update") {
+    const projectId = parseNonEmptyString(params.projectId);
+    const itemId = parseNonEmptyString(params.itemId);
+    const fieldId = parseNonEmptyString(params.fieldId);
+    if (projectId === null || itemId === null || fieldId === null) {
+      throw new Error(
+        "Missing or invalid projectId/itemId/fieldId for project_v2.item.field.update"
+      );
+    }
+    const args = [
+      ...commandTokens(card, "project item-edit"),
+      "--project-id",
+      projectId,
+      "--id",
+      itemId,
+      "--field-id",
+      fieldId
+    ];
+    const valueText = parseNonEmptyString(params.valueText);
+    const valueDate = parseNonEmptyString(params.valueDate);
+    const valueSingleSelectOptionId = parseNonEmptyString(params.valueSingleSelectOptionId);
+    const valueIterationId = parseNonEmptyString(params.valueIterationId);
+    const clear = params.clear === true;
+    if (valueText !== null) {
+      args.push("--text", valueText);
+    } else if (typeof params.valueNumber === "number" && Number.isFinite(params.valueNumber)) {
+      args.push("--number", String(params.valueNumber));
+    } else if (valueDate !== null) {
+      args.push("--date", valueDate);
+    } else if (valueSingleSelectOptionId !== null) {
+      args.push("--single-select-option-id", valueSingleSelectOptionId);
+    } else if (valueIterationId !== null) {
+      args.push("--iteration-id", valueIterationId);
+    } else if (clear) {
+      args.push("--clear");
+    } else {
+      throw new Error("Missing field value update for project_v2.item.field.update");
+    }
+    return args;
+  }
+  throw new Error(`Unsupported CLI capability: ${capabilityId}`);
+}
+function parseCliData(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    return {};
+  }
+  return JSON.parse(trimmed);
+}
+function normalizeListItem(item) {
+  if (typeof item !== "object" || item === null || Array.isArray(item)) {
+    return {};
+  }
+  const input = item;
+  return {
+    id: input.id,
+    number: input.number,
+    title: input.title,
+    state: input.state,
+    url: input.url
+  };
+}
+function normalizeWorkflowItem(item) {
+  if (typeof item !== "object" || item === null || Array.isArray(item)) {
+    return {
+      id: 0,
+      name: null,
+      path: null,
+      state: null
+    };
+  }
+  const input = item;
+  return {
+    id: typeof input.id === "number" ? input.id : 0,
+    name: typeof input.name === "string" ? input.name : null,
+    path: typeof input.path === "string" ? input.path : null,
+    state: typeof input.state === "string" ? input.state : null
+  };
+}
+function normalizeProjectV2Summary(data) {
+  const input = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+  return {
+    id: typeof input.id === "string" ? input.id : null,
+    title: typeof input.title === "string" ? input.title : null,
+    shortDescription: typeof input.shortDescription === "string" ? input.shortDescription : null,
+    public: typeof input.public === "boolean" ? input.public : null,
+    closed: typeof input.closed === "boolean" ? input.closed : null,
+    url: typeof input.url === "string" ? input.url : null
+  };
+}
+function normalizeCheckItem(item) {
+  if (typeof item !== "object" || item === null || Array.isArray(item)) {
+    return {
+      name: null,
+      state: null,
+      bucket: null,
+      workflow: null,
+      link: null
+    };
+  }
+  const input = item;
+  return {
+    name: typeof input.name === "string" ? input.name : null,
+    state: typeof input.state === "string" ? input.state : null,
+    bucket: typeof input.bucket === "string" ? input.bucket : null,
+    workflow: typeof input.workflow === "string" ? input.workflow : null,
+    link: typeof input.link === "string" ? input.link : null
+  };
+}
+function normalizeCheckBucket(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  return value.trim().toLowerCase();
+}
+function isCheckFailureBucket(bucket) {
+  const normalized = normalizeCheckBucket(bucket);
+  if (!normalized) {
+    return false;
+  }
+  return normalized === "fail" || normalized === "cancel";
+}
+function isCheckPendingBucket(bucket) {
+  const normalized = normalizeCheckBucket(bucket);
+  if (!normalized) {
+    return false;
+  }
+  return normalized === "pending";
+}
+function isCheckPassBucket(bucket) {
+  const normalized = normalizeCheckBucket(bucket);
+  if (!normalized) {
+    return false;
+  }
+  return normalized === "pass";
+}
+function normalizeCliData(capabilityId, data, params, context) {
+  const normalizeRelease = (input) => {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      return {
+        id: 0,
+        tagName: null,
+        name: null,
+        isDraft: false,
+        isPrerelease: false,
+        url: null,
+        targetCommitish: null,
+        createdAt: null,
+        publishedAt: null
+      };
+    }
+    const record = input;
+    return {
+      id: typeof record.id === "number" ? record.id : 0,
+      tagName: typeof record.tag_name === "string" ? record.tag_name : null,
+      name: typeof record.name === "string" ? record.name : null,
+      isDraft: typeof record.draft === "boolean" ? record.draft : false,
+      isPrerelease: typeof record.prerelease === "boolean" ? record.prerelease : false,
+      url: typeof record.html_url === "string" ? record.html_url : null,
+      targetCommitish: typeof record.target_commitish === "string" ? record.target_commitish : null,
+      createdAt: typeof record.created_at === "string" ? record.created_at : null,
+      publishedAt: typeof record.published_at === "string" ? record.published_at : null
+    };
+  };
+  if (capabilityId === "repo.view") {
+    const input = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+    const defaultBranchRef = typeof input.defaultBranchRef === "object" && input.defaultBranchRef !== null ? input.defaultBranchRef : null;
+    return {
+      id: input.id,
+      name: input.name,
+      nameWithOwner: input.nameWithOwner,
+      isPrivate: input.isPrivate,
+      stargazerCount: input.stargazerCount,
+      forkCount: input.forkCount,
+      url: input.url,
+      defaultBranch: typeof defaultBranchRef?.name === "string" ? defaultBranchRef.name : null
+    };
+  }
+  if (capabilityId === "repo.labels.list") {
+    const labels = Array.isArray(data) ? data : [];
+    return {
+      items: labels.map((label) => {
+        if (typeof label !== "object" || label === null || Array.isArray(label)) {
+          return {
+            id: null,
+            name: null,
+            description: null,
+            color: null,
+            isDefault: null
+          };
+        }
+        const record = label;
+        return {
+          id: typeof record.id === "string" ? record.id : null,
+          name: typeof record.name === "string" ? record.name : null,
+          description: typeof record.description === "string" ? record.description : null,
+          color: typeof record.color === "string" ? record.color : null,
+          isDefault: typeof record.isDefault === "boolean" ? record.isDefault : null
+        };
+      }),
+      pageInfo: {
+        hasNextPage: false,
+        endCursor: null
+      }
+    };
+  }
+  if (capabilityId === "repo.issue_types.list") {
+    const root = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+    const payload = typeof root.data === "object" && root.data !== null && !Array.isArray(root.data) ? root.data : {};
+    const repository = typeof payload.repository === "object" && payload.repository !== null && !Array.isArray(payload.repository) ? payload.repository : {};
+    const connection = typeof repository.issueTypes === "object" && repository.issueTypes !== null && !Array.isArray(repository.issueTypes) ? repository.issueTypes : {};
+    const nodes = Array.isArray(connection.nodes) ? connection.nodes : [];
+    const pageInfo = typeof connection.pageInfo === "object" && connection.pageInfo !== null && !Array.isArray(connection.pageInfo) ? connection.pageInfo : {};
+    return {
+      items: nodes.map((node) => {
+        if (typeof node !== "object" || node === null || Array.isArray(node)) {
+          return {
+            id: null,
+            name: null,
+            color: null,
+            isEnabled: null
+          };
+        }
+        const record = node;
+        return {
+          id: typeof record.id === "string" ? record.id : null,
+          name: typeof record.name === "string" ? record.name : null,
+          color: typeof record.color === "string" ? record.color : null,
+          isEnabled: typeof record.isEnabled === "boolean" ? record.isEnabled : null
+        };
+      }),
+      pageInfo: {
+        hasNextPage: typeof pageInfo.hasNextPage === "boolean" ? pageInfo.hasNextPage : false,
+        endCursor: typeof pageInfo.endCursor === "string" ? pageInfo.endCursor : null
+      }
+    };
+  }
+  if (capabilityId === "issue.list" || capabilityId === "pr.list") {
+    const items = Array.isArray(data) ? data.map((entry) => normalizeListItem(entry)) : [];
+    return {
+      items,
+      pageInfo: {
+        hasNextPage: false,
+        endCursor: null
+      }
+    };
+  }
+  if (capabilityId === "issue.comments.list") {
+    if (parseStrictPositiveInt(params.first) === null) {
+      throw new Error("Missing or invalid first for issue.comments.list");
+    }
+    const input = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+    const commentsConnection = typeof input.data === "object" && input.data !== null && !Array.isArray(input.data) ? input.data.repository : null;
+    const repository = typeof commentsConnection === "object" && commentsConnection !== null && !Array.isArray(commentsConnection) ? commentsConnection : null;
+    const issue = typeof repository?.issue === "object" && repository.issue !== null && !Array.isArray(repository.issue) ? repository.issue : null;
+    const comments = typeof issue?.comments === "object" && issue.comments !== null && !Array.isArray(issue.comments) ? issue.comments : null;
+    const nodes = Array.isArray(comments?.nodes) ? comments.nodes : null;
+    const pageInfo = typeof comments?.pageInfo === "object" && comments.pageInfo !== null && !Array.isArray(comments.pageInfo) ? comments.pageInfo : null;
+    if (nodes === null || pageInfo === null || typeof pageInfo.hasNextPage !== "boolean") {
+      throw new Error("Invalid CLI payload: comments connection is malformed");
+    }
+    const normalizedItems = nodes.flatMap((comment) => {
+      if (typeof comment !== "object" || comment === null || Array.isArray(comment)) {
+        throw new Error("Invalid CLI payload: comment item must be an object");
+      }
+      const commentRecord = comment;
+      const author = typeof commentRecord.author === "object" && commentRecord.author !== null ? commentRecord.author : null;
+      if (typeof commentRecord.id !== "string" || typeof commentRecord.body !== "string" || typeof commentRecord.url !== "string" || typeof commentRecord.createdAt !== "string") {
+        throw new Error("Invalid CLI payload: comment item has invalid field types");
+      }
+      return [
+        {
+          id: commentRecord.id,
+          body: commentRecord.body,
+          authorLogin: typeof author?.login === "string" ? author.login : null,
+          url: commentRecord.url,
+          createdAt: commentRecord.createdAt
+        }
+      ];
+    });
+    return {
+      items: normalizedItems,
+      pageInfo: {
+        hasNextPage: pageInfo.hasNextPage,
+        endCursor: typeof pageInfo.endCursor === "string" ? pageInfo.endCursor : null
+      }
+    };
+  }
+  if (capabilityId === "pr.status.checks" || capabilityId === "pr.checks.get_failed") {
+    const checks = Array.isArray(data) ? data.map((entry) => normalizeCheckItem(entry)) : [];
+    const failed = checks.filter((entry) => isCheckFailureBucket(entry.bucket));
+    const pending = checks.filter((entry) => isCheckPendingBucket(entry.bucket));
+    const passed = checks.filter((entry) => isCheckPassBucket(entry.bucket));
+    return {
+      items: capabilityId === "pr.checks.get_failed" ? failed : checks,
+      summary: {
+        total: checks.length,
+        failed: failed.length,
+        pending: pending.length,
+        passed: passed.length
+      }
+    };
+  }
+  if (capabilityId === "pr.mergeability.view") {
+    const input = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+    return {
+      mergeable: typeof input.mergeable === "string" ? input.mergeable : null,
+      mergeStateStatus: typeof input.mergeStateStatus === "string" ? input.mergeStateStatus : null,
+      reviewDecision: typeof input.reviewDecision === "string" ? input.reviewDecision : null,
+      isDraft: Boolean(input.isDraft),
+      state: typeof input.state === "string" ? input.state : "UNKNOWN"
+    };
+  }
+  if (capabilityId === "pr.ready_for_review.set") {
+    const prNumber = Number(params.prNumber);
+    const ready = Boolean(params.ready);
+    return {
+      prNumber,
+      isDraft: !ready
+    };
+  }
+  if (capabilityId === "pr.review.submit_approve" || capabilityId === "pr.review.submit_request_changes" || capabilityId === "pr.review.submit_comment") {
+    const prNumber = Number(params.prNumber);
+    const event = capabilityId === "pr.review.submit_approve" ? "APPROVE" : capabilityId === "pr.review.submit_request_changes" ? "REQUEST_CHANGES" : "COMMENT";
+    return {
+      prNumber,
+      event,
+      submitted: true,
+      body: typeof params.body === "string" ? params.body : null
+    };
+  }
+  if (capabilityId === "pr.merge.execute") {
+    const method = params.method === "squash" || params.method === "rebase" ? params.method : "merge";
+    return {
+      prNumber: Number(params.prNumber),
+      method,
+      queued: true,
+      deleteBranch: params.deleteBranch === true
+    };
+  }
+  if (capabilityId === "pr.checks.rerun_failed" || capabilityId === "pr.checks.rerun_all") {
+    const effectiveMode = context?.effectiveRerunMode === "all" ? "all" : capabilityId === "pr.checks.rerun_failed" ? "failed" : "all";
+    return {
+      prNumber: Number(params.prNumber),
+      runId: Number(params.runId),
+      mode: effectiveMode,
+      queued: true
+    };
+  }
+  if (capabilityId === "pr.reviewers.request") {
+    const reviewers = Array.isArray(params.reviewers) ? params.reviewers.filter(
+      (value) => typeof value === "string" && value.trim().length > 0
+    ) : [];
+    return {
+      prNumber: Number(params.prNumber),
+      reviewers,
+      updated: true
+    };
+  }
+  if (capabilityId === "pr.assignees.update") {
+    const add = Array.isArray(params.add) ? params.add.filter(
+      (value) => typeof value === "string" && value.trim().length > 0
+    ) : [];
+    const remove = Array.isArray(params.remove) ? params.remove.filter(
+      (value) => typeof value === "string" && value.trim().length > 0
+    ) : [];
+    return {
+      prNumber: Number(params.prNumber),
+      add,
+      remove,
+      updated: true
+    };
+  }
+  if (capabilityId === "pr.branch.update") {
+    return {
+      prNumber: Number(params.prNumber),
+      updated: true
+    };
+  }
+  if (capabilityId === "check_run.annotations.list") {
+    const annotations = Array.isArray(data) ? data : [];
+    return {
+      items: annotations.map((annotation) => {
+        if (typeof annotation !== "object" || annotation === null || Array.isArray(annotation)) {
+          return {
+            path: null,
+            startLine: null,
+            endLine: null,
+            level: null,
+            message: null,
+            title: null,
+            details: null
+          };
+        }
+        const record = annotation;
+        return {
+          path: typeof record.path === "string" ? record.path : null,
+          startLine: typeof record.start_line === "number" ? record.start_line : null,
+          endLine: typeof record.end_line === "number" ? record.end_line : null,
+          level: typeof record.annotation_level === "string" ? record.annotation_level : null,
+          message: typeof record.message === "string" ? record.message : null,
+          title: typeof record.title === "string" ? record.title : null,
+          details: typeof record.raw_details === "string" ? record.raw_details : null
+        };
+      })
+    };
+  }
+  if (capabilityId === "workflow_runs.list") {
+    const runs = Array.isArray(data) ? data : [];
+    return {
+      items: runs.map((run) => {
+        if (typeof run !== "object" || run === null || Array.isArray(run)) {
+          return {
+            id: 0,
+            workflowName: null,
+            status: null,
+            conclusion: null,
+            headBranch: null,
+            url: null
+          };
+        }
+        const record = run;
+        return {
+          id: typeof record.databaseId === "number" ? record.databaseId : 0,
+          workflowName: typeof record.workflowName === "string" ? record.workflowName : null,
+          status: typeof record.status === "string" ? record.status : null,
+          conclusion: typeof record.conclusion === "string" ? record.conclusion : null,
+          headBranch: typeof record.headBranch === "string" ? record.headBranch : null,
+          url: typeof record.url === "string" ? record.url : null
+        };
+      }),
+      pageInfo: {
+        hasNextPage: false,
+        endCursor: null
+      }
+    };
+  }
+  if (capabilityId === "workflow_run.jobs.list") {
+    const root = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+    const jobs = Array.isArray(root.jobs) ? root.jobs : [];
+    return {
+      items: jobs.map((job) => {
+        if (typeof job !== "object" || job === null || Array.isArray(job)) {
+          return {
+            id: 0,
+            name: null,
+            status: null,
+            conclusion: null,
+            startedAt: null,
+            completedAt: null,
+            url: null
+          };
+        }
+        const record = job;
+        return {
+          id: typeof record.databaseId === "number" ? record.databaseId : 0,
+          name: typeof record.name === "string" ? record.name : null,
+          status: typeof record.status === "string" ? record.status : null,
+          conclusion: typeof record.conclusion === "string" ? record.conclusion : null,
+          startedAt: typeof record.startedAt === "string" ? record.startedAt : null,
+          completedAt: typeof record.completedAt === "string" ? record.completedAt : null,
+          url: typeof record.url === "string" ? record.url : null
+        };
+      })
+    };
+  }
+  if (capabilityId === "workflow_job.logs.get") {
+    const jobId = Number(params.jobId);
+    const rawLog = typeof data === "string" ? data : String(data);
+    const truncated = rawLog.length > MAX_WORKFLOW_JOB_LOG_CHARS;
+    return {
+      jobId,
+      log: truncated ? rawLog.slice(0, MAX_WORKFLOW_JOB_LOG_CHARS) : rawLog,
+      truncated
+    };
+  }
+  if (capabilityId === "workflow_job.logs.analyze") {
+    const jobId = Number(params.jobId);
+    const rawLog = typeof data === "string" ? data : String(data);
+    const truncated = rawLog.length > MAX_WORKFLOW_JOB_LOG_CHARS;
+    const boundedLog = truncated ? rawLog.slice(0, MAX_WORKFLOW_JOB_LOG_CHARS) : rawLog;
+    const lines = boundedLog.split(/\r?\n/);
+    const errorLines = lines.filter((line) => /\berror\b/i.test(line));
+    const topErrorLines = errorLines.slice(0, 10);
+    const warningLines = lines.filter((line) => /\bwarn(ing)?\b/i.test(line));
+    return {
+      jobId,
+      truncated,
+      summary: {
+        errorCount: errorLines.length,
+        warningCount: warningLines.length,
+        topErrorLines
+      }
+    };
+  }
+  if (capabilityId === "workflow.list") {
+    const workflows = Array.isArray(data) ? data : [];
+    return {
+      items: workflows.map((workflow) => normalizeWorkflowItem(workflow)),
+      pageInfo: {
+        hasNextPage: false,
+        endCursor: null
+      }
+    };
+  }
+  if (capabilityId === "release.list") {
+    const items = Array.isArray(data) ? data.map((item) => normalizeRelease(item)) : [];
+    return {
+      items,
+      pageInfo: {
+        hasNextPage: false,
+        endCursor: null
+      }
+    };
+  }
+  if (capabilityId === "workflow.get") {
+    const input = normalizeWorkflowItem(data);
+    const root = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+    return {
+      ...input,
+      url: typeof root.url === "string" ? root.url : null
+    };
+  }
+  if (capabilityId === "workflow_run.get") {
+    const input = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+    return {
+      id: typeof input.databaseId === "number" ? input.databaseId : 0,
+      workflowName: typeof input.workflowName === "string" ? input.workflowName : null,
+      status: typeof input.status === "string" ? input.status : null,
+      conclusion: typeof input.conclusion === "string" ? input.conclusion : null,
+      headBranch: typeof input.headBranch === "string" ? input.headBranch : null,
+      headSha: typeof input.headSha === "string" ? input.headSha : null,
+      event: typeof input.event === "string" ? input.event : null,
+      createdAt: typeof input.createdAt === "string" ? input.createdAt : null,
+      updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : null,
+      startedAt: typeof input.startedAt === "string" ? input.startedAt : null,
+      url: typeof input.url === "string" ? input.url : null
+    };
+  }
+  if (capabilityId === "workflow_run.rerun_all") {
+    return {
+      runId: Number(params.runId),
+      status: "requested"
+    };
+  }
+  if (capabilityId === "workflow_run.cancel") {
+    return {
+      runId: Number(params.runId),
+      status: "cancel_requested"
+    };
+  }
+  if (capabilityId === "workflow_run.artifacts.list") {
+    const root = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+    const artifacts = Array.isArray(root.artifacts) ? root.artifacts : [];
+    return {
+      items: artifacts.map((artifact) => {
+        if (typeof artifact !== "object" || artifact === null || Array.isArray(artifact)) {
+          return {
+            id: 0,
+            name: null,
+            sizeInBytes: null,
+            archiveDownloadUrl: null
+          };
+        }
+        const record = artifact;
+        return {
+          id: typeof record.id === "number" ? record.id : 0,
+          name: typeof record.name === "string" ? record.name : null,
+          sizeInBytes: typeof record.sizeInBytes === "number" ? record.sizeInBytes : null,
+          archiveDownloadUrl: typeof record.archiveDownloadUrl === "string" ? record.archiveDownloadUrl : null
+        };
+      }),
+      pageInfo: {
+        hasNextPage: false,
+        endCursor: null
+      }
+    };
+  }
+  if (capabilityId === "project_v2.org.get" || capabilityId === "project_v2.user.get") {
+    return normalizeProjectV2Summary(data);
+  }
+  if (capabilityId === "project_v2.fields.list") {
+    const root = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+    const fields = Array.isArray(root.fields) ? root.fields : [];
+    return {
+      items: fields.map((field) => {
+        if (typeof field !== "object" || field === null || Array.isArray(field)) {
+          return {
+            id: null,
+            name: null,
+            dataType: null
+          };
+        }
+        const record = field;
+        return {
+          id: typeof record.id === "string" ? record.id : null,
+          name: typeof record.name === "string" ? record.name : null,
+          dataType: typeof record.dataType === "string" ? record.dataType : null
+        };
+      }),
+      pageInfo: {
+        hasNextPage: false,
+        endCursor: null
+      }
+    };
+  }
+  if (capabilityId === "project_v2.items.list") {
+    const root = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+    const items = Array.isArray(root.items) ? root.items : [];
+    return {
+      items: items.map((item) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+          return {
+            id: null,
+            contentType: null,
+            contentNumber: null,
+            contentTitle: null
+          };
+        }
+        const record = item;
+        const content = typeof record.content === "object" && record.content !== null && !Array.isArray(record.content) ? record.content : {};
+        return {
+          id: typeof record.id === "string" ? record.id : null,
+          contentType: typeof content.type === "string" ? content.type : null,
+          contentNumber: typeof content.number === "number" ? content.number : null,
+          contentTitle: typeof content.title === "string" ? content.title : null
+        };
+      }),
+      pageInfo: {
+        hasNextPage: false,
+        endCursor: null
+      }
+    };
+  }
+  if (capabilityId === "project_v2.item.add_issue") {
+    const root = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+    return {
+      itemId: typeof root.id === "string" ? root.id : null,
+      added: true
+    };
+  }
+  if (capabilityId === "project_v2.item.field.update") {
+    return {
+      itemId: parseNonEmptyString(params.itemId),
+      updated: true
+    };
+  }
+  if (capabilityId === "release.get" || capabilityId === "release.create_draft" || capabilityId === "release.update") {
+    return normalizeRelease(data);
+  }
+  if (capabilityId === "release.publish_draft") {
+    const release = normalizeRelease(data);
+    return {
+      ...release,
+      wasDraft: Boolean(context?.wasDraft)
+    };
+  }
+  if (capabilityId === "workflow_dispatch.run") {
+    return {
+      workflowId: String(params.workflowId),
+      ref: String(params.ref),
+      dispatched: true
+    };
+  }
+  if (capabilityId === "workflow_run.rerun_failed") {
+    return {
+      runId: Number(params.runId),
+      rerunFailed: true
+    };
+  }
+  if (capabilityId === "issue.view" || capabilityId === "pr.view") {
+    return normalizeListItem(data);
+  }
+  return data;
+}
+async function runCliCapability(runner, capabilityId, params, card) {
+  try {
+    if (capabilityId === "release.publish_draft") {
+      const owner = String(params.owner ?? "");
+      const name = String(params.name ?? "");
+      const releaseId = parseStrictPositiveInt(params.releaseId);
+      if (!owner || !name || releaseId === null) {
+        throw new Error("Missing owner/name/releaseId for release.publish_draft");
+      }
+      const readArgs = [
+        ...commandTokens(card, "api"),
+        `repos/${owner}/${name}/releases/${releaseId}`
+      ];
+      const readResult = await runner.run("gh", readArgs, DEFAULT_TIMEOUT_MS);
+      if (readResult.exitCode !== 0) {
+        const code = mapErrorToCode(readResult.stderr);
+        return normalizeError(
+          {
+            code,
+            message: sanitizeCliErrorMessage(readResult.stderr, readResult.exitCode),
+            retryable: isRetryableErrorCode(code),
+            details: { capabilityId, exitCode: readResult.exitCode }
+          },
+          "cli",
+          { capabilityId, reason: "CARD_FALLBACK" }
+        );
+      }
+      const currentRelease = parseCliData(readResult.stdout);
+      const currentDraftValue = typeof currentRelease === "object" && currentRelease !== null && !Array.isArray(currentRelease) ? currentRelease.draft : void 0;
+      if (currentDraftValue !== true) {
+        return normalizeError(
+          {
+            code: errorCodes.Validation,
+            message: "release.publish_draft requires an existing draft release",
+            retryable: false
+          },
+          "cli",
+          { capabilityId, reason: "CARD_FALLBACK" }
+        );
+      }
+      const args2 = buildArgs(capabilityId, params, card);
+      const result2 = await runner.run("gh", args2, DEFAULT_TIMEOUT_MS);
+      if (result2.exitCode !== 0) {
+        const code = mapErrorToCode(result2.stderr);
+        return normalizeError(
+          {
+            code,
+            message: sanitizeCliErrorMessage(result2.stderr, result2.exitCode),
+            retryable: isRetryableErrorCode(code),
+            details: { capabilityId, exitCode: result2.exitCode }
+          },
+          "cli",
+          { capabilityId, reason: "CARD_FALLBACK" }
+        );
+      }
+      const normalized2 = normalizeCliData(capabilityId, parseCliData(result2.stdout), params, {
+        wasDraft: true
+      });
+      return normalizeResult(normalized2, "cli", { capabilityId, reason: "CARD_FALLBACK" });
+    }
+    const args = buildArgs(capabilityId, params, card);
+    const result = await runner.run("gh", args, DEFAULT_TIMEOUT_MS);
+    let failureStderr = result.stderr;
+    if (result.exitCode !== 0) {
+      if (capabilityId === "pr.checks.rerun_failed" && shouldFallbackRerunFailedToAll(result.stderr)) {
+        const rerunAllArgs = buildArgs("pr.checks.rerun_all", params, card);
+        const rerunAllResult = await runner.run("gh", rerunAllArgs, DEFAULT_TIMEOUT_MS);
+        if (rerunAllResult.exitCode === 0) {
+          const rerunData = NON_JSON_STDOUT_CAPABILITIES.has(capabilityId) ? {} : parseCliData(rerunAllResult.stdout);
+          const fallbackData = normalizeCliData(capabilityId, rerunData, params, {
+            effectiveRerunMode: "all"
+          });
+          return normalizeResult(fallbackData, "cli", { capabilityId, reason: "CARD_FALLBACK" });
+        }
+        failureStderr = rerunAllResult.stderr || rerunAllResult.stdout || result.stderr;
+      }
+      const code = mapErrorToCode(failureStderr);
+      return normalizeError(
+        {
+          code,
+          message: sanitizeCliErrorMessage(failureStderr, result.exitCode),
+          retryable: isRetryableErrorCode(code),
+          details: { capabilityId, exitCode: result.exitCode }
+        },
+        "cli",
+        { capabilityId, reason: "CARD_FALLBACK" }
+      );
+    }
+    const data = capabilityId === "workflow_job.logs.get" || capabilityId === "workflow_job.logs.analyze" ? result.stdout : NON_JSON_STDOUT_CAPABILITIES.has(capabilityId) ? {} : parseCliData(result.stdout);
+    const normalized = normalizeCliData(capabilityId, data, params);
+    return normalizeResult(normalized, "cli", { capabilityId, reason: "CARD_FALLBACK" });
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return normalizeError(
+        {
+          code: errorCodes.Server,
+          message: "Failed to parse CLI JSON output",
+          retryable: false
+        },
+        "cli",
+        { capabilityId, reason: "CARD_FALLBACK" }
+      );
+    }
+    if (error instanceof Error && error.message.toLowerCase().includes("invalid cli payload")) {
+      return normalizeError(
+        {
+          code: errorCodes.Server,
+          message: error.message,
+          retryable: false
+        },
+        "cli",
+        { capabilityId, reason: "CARD_FALLBACK" }
+      );
+    }
+    if (error instanceof Error && error.message.toLowerCase().includes("invalid after cursor")) {
+      return normalizeError(
+        {
+          code: errorCodes.Validation,
+          message: error.message,
+          retryable: false
+        },
+        "cli",
+        { capabilityId, reason: "CARD_FALLBACK" }
+      );
+    }
+    if (error instanceof Error && error.message.toLowerCase().includes("only supports draft=true")) {
+      return normalizeError(
+        {
+          code: errorCodes.Validation,
+          message: error.message,
+          retryable: false
+        },
+        "cli",
+        { capabilityId, reason: "CARD_FALLBACK" }
+      );
+    }
+    const code = mapErrorToCode(error);
+    return normalizeError(
+      {
+        code,
+        message: error instanceof Error ? error.message : String(error),
+        retryable: isRetryableErrorCode(code)
+      },
+      "cli",
+      { capabilityId, reason: "CARD_FALLBACK" }
+    );
+  }
+}
+
+// src/core/execution/adapters/graphql-capability-adapter.ts
+var DEFAULT_LIST_FIRST2 = 30;
+function unsupportedGraphqlCapability(capabilityId) {
+  return normalizeError(
+    {
+      code: errorCodes.AdapterUnsupported,
+      message: `Unsupported GraphQL capability: ${capabilityId}`,
+      retryable: false
+    },
+    "graphql",
+    { capabilityId, reason: "CAPABILITY_LIMIT" }
+  );
+}
+function withDefaultFirst(params) {
+  if (params.first === void 0) {
+    return {
+      ...params,
+      first: DEFAULT_LIST_FIRST2
+    };
+  }
+  return params;
+}
+function requireNonEmptyString(params, field, capabilityId) {
+  const value = params[field];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Missing or invalid ${field} for ${capabilityId}`);
+  }
+  return value;
+}
+async function runGraphqlCapability(client, capabilityId, params) {
+  try {
+    if (capabilityId === "repo.view") {
+      const data = await client.fetchRepoView(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.view") {
+      const data = await client.fetchIssueView(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.list") {
+      const data = await client.fetchIssueList(withDefaultFirst(params));
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.comments.list") {
+      const data = await client.fetchIssueCommentsList(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.create") {
+      if (!client.createIssue) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.createIssue(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.update") {
+      if (!client.updateIssue) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.updateIssue(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.close") {
+      if (!client.closeIssue) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.closeIssue(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.reopen") {
+      if (!client.reopenIssue) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.reopenIssue(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.delete") {
+      if (!client.deleteIssue) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.deleteIssue(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.labels.update") {
+      if (!client.updateIssueLabels) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.updateIssueLabels(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.assignees.update") {
+      if (!client.updateIssueAssignees) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.updateIssueAssignees(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.milestone.set") {
+      if (!client.setIssueMilestone) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.setIssueMilestone(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.comments.create") {
+      if (!client.createIssueComment) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.createIssueComment(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.linked_prs.list") {
+      if (!client.fetchIssueLinkedPrs) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.fetchIssueLinkedPrs(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.relations.get") {
+      if (!client.fetchIssueRelations) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.fetchIssueRelations(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.parent.set") {
+      if (!client.setIssueParent) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.setIssueParent(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.parent.remove") {
+      if (!client.removeIssueParent) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.removeIssueParent(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.blocked_by.add") {
+      if (!client.addIssueBlockedBy) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.addIssueBlockedBy(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "issue.blocked_by.remove") {
+      if (!client.removeIssueBlockedBy) {
+        return unsupportedGraphqlCapability(capabilityId);
+      }
+      const data = await client.removeIssueBlockedBy(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "pr.view") {
+      const data = await client.fetchPrView(params);
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "pr.list") {
+      const data = await client.fetchPrList(withDefaultFirst(params));
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "pr.comments.list") {
+      const data = await client.fetchPrCommentsList(withDefaultFirst(params));
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "pr.reviews.list") {
+      const data = await client.fetchPrReviewsList(withDefaultFirst(params));
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "pr.diff.list_files") {
+      const data = await client.fetchPrDiffListFiles(
+        withDefaultFirst(params)
+      );
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "pr.comment.reply") {
+      const threadId = requireNonEmptyString(params, "threadId", capabilityId);
+      const body = requireNonEmptyString(params, "body", capabilityId);
+      const data = await client.replyToReviewThread({ threadId, body });
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "pr.comment.resolve") {
+      const threadId = requireNonEmptyString(params, "threadId", capabilityId);
+      const data = await client.resolveReviewThread({ threadId });
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    if (capabilityId === "pr.comment.unresolve") {
+      const threadId = requireNonEmptyString(params, "threadId", capabilityId);
+      const data = await client.unresolveReviewThread({ threadId });
+      return normalizeResult(data, "graphql", { capabilityId, reason: "CARD_PREFERRED" });
+    }
+    return unsupportedGraphqlCapability(capabilityId);
+  } catch (error) {
+    const code = mapErrorToCode(error);
+    return normalizeError(
+      {
+        code,
+        message: error instanceof Error ? error.message : String(error),
+        retryable: isRetryableErrorCode(code)
+      },
+      "graphql",
+      { capabilityId, reason: "CARD_PREFERRED" }
+    );
+  }
+}
+
+// src/core/execution/preflight.ts
+function preflightCheck(input) {
+  if (input.route === "rest") {
+    return {
+      ok: false,
+      code: errorCodes.AdapterUnsupported,
+      message: "REST route is planned but not implemented in v1",
+      retryable: false,
+      details: { route: input.route }
+    };
+  }
+  if (input.route === "cli" && input.ghCliAvailable === false) {
+    return {
+      ok: false,
+      code: errorCodes.AdapterUnsupported,
+      message: "GitHub CLI is required for cli route",
+      retryable: false,
+      details: { route: input.route }
+    };
+  }
+  if (input.route === "cli" && input.ghAuthenticated === false) {
+    return {
+      ok: false,
+      code: errorCodes.Auth,
+      message: "GitHub CLI authentication is required for cli route",
+      retryable: false,
+      details: { route: input.route }
+    };
+  }
+  if (input.route === "graphql") {
+    const token = input.githubToken?.trim();
+    if (!token) {
+      return {
+        ok: false,
+        code: errorCodes.Auth,
+        message: "GitHub token is required for graphql route",
+        retryable: false,
+        details: { route: input.route }
+      };
+    }
+  }
+  return { ok: true };
+}
+
+// src/core/routing/policy.ts
+var routePreferenceOrder = ["cli", "graphql"];
+
+// src/core/routing/engine.ts
+var DEFAULT_REASON = "DEFAULT_POLICY";
+var CLI_ENV_CACHE_TTL_MS = 3e4;
+var cliEnvironmentCache = /* @__PURE__ */ new WeakMap();
+var cliEnvironmentInFlight = /* @__PURE__ */ new WeakMap();
+var defaultCliRunner = createSafeCliCommandRunner();
+async function detectCliEnvironment(runner) {
+  try {
+    const version = await runner.run("gh", ["--version"], 1500);
+    if (version.exitCode !== 0) {
+      return {
+        ghCliAvailable: false,
+        ghAuthenticated: false
+      };
+    }
+    const auth = await runner.run("gh", ["auth", "status"], 2500);
+    return {
+      ghCliAvailable: true,
+      ghAuthenticated: auth.exitCode === 0
+    };
+  } catch {
+    return {
+      ghCliAvailable: false,
+      ghAuthenticated: false
+    };
+  }
+}
+async function detectCliEnvironmentCached(runner) {
+  const now = Date.now();
+  const cached = cliEnvironmentCache.get(runner);
+  if (cached && cached.expiresAt > now) {
+    return cached.value;
+  }
+  const inFlight = cliEnvironmentInFlight.get(runner);
+  if (inFlight) {
+    return inFlight;
+  }
+  const probePromise = detectCliEnvironment(runner).then((value) => {
+    cliEnvironmentCache.set(runner, {
+      value,
+      expiresAt: Date.now() + CLI_ENV_CACHE_TTL_MS
+    });
+    cliEnvironmentInFlight.delete(runner);
+    return value;
+  }).catch((error) => {
+    cliEnvironmentInFlight.delete(runner);
+    throw error;
+  });
+  cliEnvironmentInFlight.set(runner, probePromise);
+  return probePromise;
+}
+async function executeTask(request, deps) {
+  const reason = deps.reason ?? DEFAULT_REASON;
+  const card = getOperationCard(request.task);
+  if (!card) {
+    return normalizeError(
+      {
+        code: errorCodes.Validation,
+        message: `Unsupported task: ${request.task}`,
+        retryable: false
+      },
+      routePreferenceOrder[0],
+      { capabilityId: request.task, reason }
+    );
+  }
+  const cliRunner = deps.cliRunner ?? defaultCliRunner;
+  return execute({
+    card,
+    params: request.input,
+    routingContext: {
+      ghCliAvailable: deps.ghCliAvailable,
+      ghAuthenticated: deps.ghAuthenticated,
+      githubTokenPresent: Boolean(deps.githubToken)
+    },
+    retry: {
+      maxAttemptsPerRoute: 2
+    },
+    preflight: async (route) => {
+      const preflightInput = { route };
+      if (deps.githubToken !== void 0) {
+        preflightInput.githubToken = deps.githubToken;
+      }
+      if (route === "cli") {
+        if (deps.ghCliAvailable !== void 0) {
+          preflightInput.ghCliAvailable = deps.ghCliAvailable;
+        }
+        if (deps.ghAuthenticated !== void 0) {
+          preflightInput.ghAuthenticated = deps.ghAuthenticated;
+        }
+        if (preflightInput.ghCliAvailable === void 0 || preflightInput.ghAuthenticated === void 0) {
+          if (deps.skipGhPreflight === true) {
+            if (preflightInput.ghCliAvailable === void 0) {
+              preflightInput.ghCliAvailable = true;
+            }
+            if (preflightInput.ghAuthenticated === void 0) {
+              preflightInput.ghAuthenticated = true;
+            }
+          } else {
+            const detected = await detectCliEnvironmentCached(cliRunner);
+            if (preflightInput.ghCliAvailable === void 0) {
+              preflightInput.ghCliAvailable = detected.ghCliAvailable;
+            }
+            if (preflightInput.ghAuthenticated === void 0) {
+              preflightInput.ghAuthenticated = detected.ghAuthenticated;
+            }
+          }
+        }
+      }
+      return preflightCheck(preflightInput);
+    },
+    routes: {
+      graphql: async () => runGraphqlCapability(
+        deps.githubClient,
+        request.task,
+        request.input
+      ),
+      cli: async () => {
+        return runCliCapability(
+          cliRunner,
+          request.task,
+          request.input,
+          card
+        );
+      },
+      rest: async () => normalizeError(
+        {
+          code: errorCodes.AdapterUnsupported,
+          message: `Route 'rest' is not implemented for task '${request.task}'`,
+          retryable: false,
+          details: { route: "rest", task: request.task }
+        },
+        "rest",
+        { capabilityId: request.task, reason }
+      )
+    }
+  });
+}
+
+// src/gql/client.ts
+import { print } from "graphql";
+
+// src/gql/operations/issue-comments-list.generated.ts
+var IssueCommentsListDocument = `
+    query IssueCommentsList($owner: String!, $name: String!, $issueNumber: Int!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $issueNumber) {
+      comments(first: $first, after: $after) {
+        nodes {
+          id
+          body
+          createdAt
+          url
+          author {
+            login
+          }
+        }
+        pageInfo {
+          endCursor
+          hasNextPage
+        }
+      }
+    }
+  }
+}
+    `;
+var defaultWrapper = (action, _operationName, _operationType, _variables) => action();
+function getSdk(client, withWrapper = defaultWrapper) {
+  return {
+    IssueCommentsList(variables, requestHeaders, signal) {
+      return withWrapper(
+        (wrappedRequestHeaders) => client.request({
+          document: IssueCommentsListDocument,
+          variables,
+          requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+          signal
+        }),
+        "IssueCommentsList",
+        "query",
+        variables
+      );
+    }
+  };
+}
+
+// src/gql/operations/issue-list.generated.ts
+var IssueListDocument = `
+    query IssueList($owner: String!, $name: String!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    issues(
+      first: $first
+      after: $after
+      orderBy: {field: CREATED_AT, direction: DESC}
+    ) {
+      nodes {
+        id
+        number
+        title
+        state
+        url
+      }
+      pageInfo {
+        endCursor
+        hasNextPage
+      }
+    }
+  }
+}
+    `;
+var defaultWrapper2 = (action, _operationName, _operationType, _variables) => action();
+function getSdk2(client, withWrapper = defaultWrapper2) {
+  return {
+    IssueList(variables, requestHeaders, signal) {
+      return withWrapper(
+        (wrappedRequestHeaders) => client.request({
+          document: IssueListDocument,
+          variables,
+          requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+          signal
+        }),
+        "IssueList",
+        "query",
+        variables
+      );
+    }
+  };
+}
+
+// src/gql/operations/issue-view.generated.ts
+var IssueViewDocument = `
+    query IssueView($owner: String!, $name: String!, $issueNumber: Int!) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $issueNumber) {
+      id
+      number
+      title
+      state
+      url
+    }
+  }
+}
+    `;
+var defaultWrapper3 = (action, _operationName, _operationType, _variables) => action();
+function getSdk3(client, withWrapper = defaultWrapper3) {
+  return {
+    IssueView(variables, requestHeaders, signal) {
+      return withWrapper(
+        (wrappedRequestHeaders) => client.request({
+          document: IssueViewDocument,
+          variables,
+          requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+          signal
+        }),
+        "IssueView",
+        "query",
+        variables
+      );
+    }
+  };
+}
+
+// src/gql/operations/pr-diff-list-files.generated.ts
+var PrDiffListFilesDocument = `
+    query PrDiffListFiles($owner: String!, $name: String!, $prNumber: Int!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $prNumber) {
+      files(first: $first, after: $after) {
+        nodes {
+          path
+          additions
+          deletions
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  }
+}
+    `;
+var defaultWrapper4 = (action, _operationName, _operationType, _variables) => action();
+function getSdk4(client, withWrapper = defaultWrapper4) {
+  return {
+    PrDiffListFiles(variables, requestHeaders, signal) {
+      return withWrapper(
+        (wrappedRequestHeaders) => client.request({
+          document: PrDiffListFilesDocument,
+          variables,
+          requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+          signal
+        }),
+        "PrDiffListFiles",
+        "query",
+        variables
+      );
+    }
+  };
+}
+
+// src/gql/operations/pr-list.generated.ts
+var PrListDocument = `
+    query PrList($owner: String!, $name: String!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequests(
+      first: $first
+      after: $after
+      orderBy: {field: CREATED_AT, direction: DESC}
+    ) {
+      nodes {
+        id
+        number
+        title
+        state
+        url
+      }
+      pageInfo {
+        endCursor
+        hasNextPage
+      }
+    }
+  }
+}
+    `;
+var defaultWrapper5 = (action, _operationName, _operationType, _variables) => action();
+function getSdk5(client, withWrapper = defaultWrapper5) {
+  return {
+    PrList(variables, requestHeaders, signal) {
+      return withWrapper(
+        (wrappedRequestHeaders) => client.request({
+          document: PrListDocument,
+          variables,
+          requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+          signal
+        }),
+        "PrList",
+        "query",
+        variables
+      );
+    }
+  };
+}
+
+// src/gql/operations/pr-reviews-list.generated.ts
+var PrReviewsListDocument = `
+    query PrReviewsList($owner: String!, $name: String!, $prNumber: Int!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $prNumber) {
+      reviews(first: $first, after: $after) {
+        nodes {
+          id
+          author {
+            login
+          }
+          body
+          state
+          submittedAt
+          url
+          commit {
+            oid
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  }
+}
+    `;
+var defaultWrapper6 = (action, _operationName, _operationType, _variables) => action();
+function getSdk6(client, withWrapper = defaultWrapper6) {
+  return {
+    PrReviewsList(variables, requestHeaders, signal) {
+      return withWrapper(
+        (wrappedRequestHeaders) => client.request({
+          document: PrReviewsListDocument,
+          variables,
+          requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+          signal
+        }),
+        "PrReviewsList",
+        "query",
+        variables
+      );
+    }
+  };
+}
+
+// src/gql/operations/pr-view.generated.ts
+var PrViewDocument = `
+    query PrView($owner: String!, $name: String!, $prNumber: Int!) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $prNumber) {
+      id
+      number
+      title
+      state
+      url
+    }
+  }
+}
+    `;
+var defaultWrapper7 = (action, _operationName, _operationType, _variables) => action();
+function getSdk7(client, withWrapper = defaultWrapper7) {
+  return {
+    PrView(variables, requestHeaders, signal) {
+      return withWrapper(
+        (wrappedRequestHeaders) => client.request({
+          document: PrViewDocument,
+          variables,
+          requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+          signal
+        }),
+        "PrView",
+        "query",
+        variables
+      );
+    }
+  };
+}
+
+// src/gql/operations/repo-view.generated.ts
+var RepoViewDocument = `
+    query RepoView($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) {
+    id
+    name
+    nameWithOwner
+    isPrivate
+    stargazerCount
+    forkCount
+    url
+    defaultBranchRef {
+      name
+    }
+  }
+}
+    `;
+var defaultWrapper8 = (action, _operationName, _operationType, _variables) => action();
+function getSdk8(client, withWrapper = defaultWrapper8) {
+  return {
+    RepoView(variables, requestHeaders, signal) {
+      return withWrapper(
+        (wrappedRequestHeaders) => client.request({
+          document: RepoViewDocument,
+          variables,
+          requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+          signal
+        }),
+        "RepoView",
+        "query",
+        variables
+      );
+    }
+  };
+}
+
+// src/gql/client.ts
+function assertRepoInput(input) {
+  if (input.owner.trim().length === 0 || input.name.trim().length === 0) {
+    throw new Error("Repository owner and name are required");
+  }
+}
+function assertIssueInput(input) {
+  if (input.owner.trim().length === 0 || input.name.trim().length === 0) {
+    throw new Error("Repository owner and name are required");
+  }
+  if (!Number.isInteger(input.issueNumber) || input.issueNumber <= 0) {
+    throw new Error("Issue number must be a positive integer");
+  }
+}
+function assertIssueListInput(input) {
+  if (input.owner.trim().length === 0 || input.name.trim().length === 0) {
+    throw new Error("Repository owner and name are required");
+  }
+  if (!Number.isInteger(input.first) || input.first <= 0) {
+    throw new Error("List page size must be a positive integer");
+  }
+}
+function assertIssueCommentsListInput(input) {
+  if (input.owner.trim().length === 0 || input.name.trim().length === 0) {
+    throw new Error("Repository owner and name are required");
+  }
+  if (!Number.isInteger(input.issueNumber) || input.issueNumber <= 0) {
+    throw new Error("Issue number must be a positive integer");
+  }
+  if (!Number.isInteger(input.first) || input.first <= 0) {
+    throw new Error("List page size must be a positive integer");
+  }
+  if (input.after !== void 0 && input.after !== null && typeof input.after !== "string") {
+    throw new Error("After cursor must be a string");
+  }
+}
+function assertNonEmptyString(value, fieldName) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${fieldName} is required`);
+  }
+  return value;
+}
+function assertOptionalString(value, fieldName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${fieldName} must be a string`);
+  }
+  return value;
+}
+function assertStringArray(value, fieldName) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.trim().length === 0)) {
+    throw new Error(`${fieldName} must be an array of non-empty strings`);
+  }
+  return value;
+}
+function assertIssueCreateInput(input) {
+  assertRepoInput({ owner: input.owner, name: input.name });
+  assertNonEmptyString(input.title, "Issue title");
+  assertOptionalString(input.body, "Issue body");
+}
+function assertIssueUpdateInput(input) {
+  assertNonEmptyString(input.issueId, "Issue id");
+  if (input.title === void 0 && input.body === void 0) {
+    throw new Error("Issue update requires at least one field");
+  }
+  if (input.title !== void 0) {
+    assertOptionalString(input.title, "Issue title");
+  }
+  if (input.body !== void 0) {
+    assertOptionalString(input.body, "Issue body");
+  }
+}
+function assertIssueMutationInput(input) {
+  assertNonEmptyString(input.issueId, "Issue id");
+}
+function assertIssueLabelsUpdateInput(input) {
+  assertIssueMutationInput({ issueId: input.issueId });
+  assertStringArray(input.labels, "Labels");
+}
+function assertIssueAssigneesUpdateInput(input) {
+  assertIssueMutationInput({ issueId: input.issueId });
+  assertStringArray(input.assignees, "Assignees");
+}
+function assertIssueMilestoneSetInput(input) {
+  assertIssueMutationInput({ issueId: input.issueId });
+  if (input.milestoneNumber !== null && (!Number.isInteger(input.milestoneNumber) || input.milestoneNumber <= 0)) {
+    throw new Error("Milestone number must be a positive integer or null");
+  }
+}
+function assertIssueCommentCreateInput(input) {
+  assertIssueMutationInput({ issueId: input.issueId });
+  assertNonEmptyString(input.body, "Issue comment body");
+}
+function assertIssueLinkedPrsListInput(input) {
+  assertIssueInput(input);
+}
+function assertIssueRelationsGetInput(input) {
+  assertIssueInput(input);
+}
+function assertIssueParentSetInput(input) {
+  assertIssueMutationInput({ issueId: input.issueId });
+  assertNonEmptyString(input.parentIssueId, "Parent issue id");
+}
+function assertIssueParentRemoveInput(input) {
+  assertIssueMutationInput({ issueId: input.issueId });
+}
+function assertIssueBlockedByInput(input) {
+  assertIssueMutationInput({ issueId: input.issueId });
+  assertNonEmptyString(input.blockedByIssueId, "Blocked-by issue id");
+}
+function assertPrInput(input) {
+  if (input.owner.trim().length === 0 || input.name.trim().length === 0) {
+    throw new Error("Repository owner and name are required");
+  }
+  if (!Number.isInteger(input.prNumber) || input.prNumber <= 0) {
+    throw new Error("PR number must be a positive integer");
+  }
+}
+function assertPrListInput(input) {
+  if (input.owner.trim().length === 0 || input.name.trim().length === 0) {
+    throw new Error("Repository owner and name are required");
+  }
+  if (!Number.isInteger(input.first) || input.first <= 0) {
+    throw new Error("List page size must be a positive integer");
+  }
+}
+function assertPrReviewsListInput(input) {
+  if (typeof input.owner !== "string" || typeof input.name !== "string" || input.owner.trim().length === 0 || input.name.trim().length === 0) {
+    throw new Error("Repository owner and name are required");
+  }
+  if (!Number.isInteger(input.prNumber) || input.prNumber <= 0) {
+    throw new Error("PR number must be a positive integer");
+  }
+  if (!Number.isInteger(input.first) || input.first <= 0) {
+    throw new Error("List page size must be a positive integer");
+  }
+}
+function assertPrDiffListFilesInput(input) {
+  if (typeof input.owner !== "string" || typeof input.name !== "string" || input.owner.trim().length === 0 || input.name.trim().length === 0) {
+    throw new Error("Repository owner and name are required");
+  }
+  if (!Number.isInteger(input.prNumber) || input.prNumber <= 0) {
+    throw new Error("PR number must be a positive integer");
+  }
+  if (!Number.isInteger(input.first) || input.first <= 0) {
+    throw new Error("List page size must be a positive integer");
+  }
+}
+function assertPrCommentsListInput(input) {
+  if (typeof input.owner !== "string" || typeof input.name !== "string" || input.owner.trim().length === 0 || input.name.trim().length === 0) {
+    throw new Error("Repository owner and name are required");
+  }
+  if (!Number.isInteger(input.prNumber) || input.prNumber <= 0) {
+    throw new Error("PR number must be a positive integer");
+  }
+  if (!Number.isInteger(input.first) || input.first <= 0) {
+    throw new Error("List page size must be a positive integer");
+  }
+  if (input.unresolvedOnly !== void 0 && typeof input.unresolvedOnly !== "boolean") {
+    throw new Error("unresolvedOnly must be a boolean");
+  }
+  if (input.includeOutdated !== void 0 && typeof input.includeOutdated !== "boolean") {
+    throw new Error("includeOutdated must be a boolean");
+  }
+  if (input.after !== void 0 && input.after !== null && typeof input.after !== "string") {
+    throw new Error("After cursor must be a string");
+  }
+}
+var PR_COMMENTS_LIST_QUERY = `
+  query PrCommentsList($owner: String!, $name: String!, $prNumber: Int!, $first: Int!, $after: String) {
+    repository(owner: $owner, name: $name) {
+      pullRequest(number: $prNumber) {
+        reviewThreads(first: $first, after: $after) {
+          edges {
+            cursor
+            node {
+              id
+              path
+              line
+              startLine
+              diffSide
+              subjectType
+              isResolved
+              isOutdated
+              viewerCanReply
+              viewerCanResolve
+              viewerCanUnresolve
+              resolvedBy {
+                login
+              }
+              comments(first: 20) {
+                nodes {
+                  id
+                  body
+                  createdAt
+                  url
+                  author {
+                    login
+                  }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+var PR_COMMENT_REPLY_MUTATION = `
+  mutation PrCommentReply($threadId: ID!, $body: String!) {
+    addPullRequestReviewThreadReply(input: { pullRequestReviewThreadId: $threadId, body: $body }) {
+      comment {
+        id
+      }
+    }
+  }
+`;
+var PR_COMMENT_RESOLVE_MUTATION = `
+  mutation PrCommentResolve($threadId: ID!) {
+    resolveReviewThread(input: { threadId: $threadId }) {
+      thread {
+        id
+        isResolved
+      }
+    }
+  }
+`;
+var PR_COMMENT_UNRESOLVE_MUTATION = `
+  mutation PrCommentUnresolve($threadId: ID!) {
+    unresolveReviewThread(input: { threadId: $threadId }) {
+      thread {
+        id
+        isResolved
+      }
+    }
+  }
+`;
+var REVIEW_THREAD_STATE_QUERY = `
+  query ReviewThreadState($threadId: ID!) {
+    node(id: $threadId) {
+      ... on PullRequestReviewThread {
+        id
+        isResolved
+      }
+    }
+  }
+`;
+var ISSUE_CREATE_REPOSITORY_ID_QUERY = `
+  query IssueCreateRepositoryId($owner: String!, $name: String!) {
+    repository(owner: $owner, name: $name) {
+      id
+    }
+  }
+`;
+var ISSUE_CREATE_MUTATION = `
+  mutation IssueCreate($repositoryId: ID!, $title: String!, $body: String) {
+    createIssue(input: { repositoryId: $repositoryId, title: $title, body: $body }) {
+      issue {
+        id
+        number
+        title
+        state
+        url
+      }
+    }
+  }
+`;
+var ISSUE_UPDATE_MUTATION = `
+  mutation IssueUpdate($issueId: ID!, $title: String, $body: String) {
+    updateIssue(input: { id: $issueId, title: $title, body: $body }) {
+      issue {
+        id
+        number
+        title
+        state
+        url
+      }
+    }
+  }
+`;
+var ISSUE_CLOSE_MUTATION = `
+  mutation IssueClose($issueId: ID!) {
+    closeIssue(input: { issueId: $issueId }) {
+      issue {
+        id
+        number
+        state
+      }
+    }
+  }
+`;
+var ISSUE_REOPEN_MUTATION = `
+  mutation IssueReopen($issueId: ID!) {
+    reopenIssue(input: { issueId: $issueId }) {
+      issue {
+        id
+        number
+        state
+      }
+    }
+  }
+`;
+var ISSUE_DELETE_MUTATION = `
+  mutation IssueDelete($issueId: ID!) {
+    deleteIssue(input: { issueId: $issueId }) {
+      clientMutationId
+    }
+  }
+`;
+var ISSUE_LABELS_UPDATE_MUTATION = `
+  mutation IssueLabelsUpdate($issueId: ID!, $labelIds: [ID!]!) {
+    updateIssue(input: { id: $issueId, labelIds: $labelIds }) {
+      issue {
+        id
+        labels(first: 50) {
+          nodes {
+            name
+          }
+        }
+      }
+    }
+  }
+`;
+var ISSUE_ASSIGNEES_UPDATE_MUTATION = `
+  mutation IssueAssigneesUpdate($issueId: ID!, $assigneeIds: [ID!]!) {
+    updateIssue(input: { id: $issueId, assigneeIds: $assigneeIds }) {
+      issue {
+        id
+        assignees(first: 50) {
+          nodes {
+            login
+          }
+        }
+      }
+    }
+  }
+`;
+var ISSUE_MILESTONE_SET_MUTATION = `
+  mutation IssueMilestoneSet($issueId: ID!, $milestoneId: ID) {
+    updateIssue(input: { id: $issueId, milestoneId: $milestoneId }) {
+      issue {
+        id
+        milestone {
+          number
+        }
+      }
+    }
+  }
+`;
+var ISSUE_LABELS_LOOKUP_QUERY = `
+  query IssueLabelsLookup($issueId: ID!) {
+    node(id: $issueId) {
+      ... on Issue {
+        repository {
+          labels(first: 100) {
+            nodes {
+              id
+              name
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var ISSUE_ASSIGNEES_LOOKUP_QUERY = `
+  query IssueAssigneesLookup($issueId: ID!) {
+    node(id: $issueId) {
+      ... on Issue {
+        repository {
+          assignableUsers(first: 100) {
+            nodes {
+              id
+              login
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var ISSUE_MILESTONE_LOOKUP_QUERY = `
+  query IssueMilestoneLookup($issueId: ID!, $milestoneNumber: Int!) {
+    node(id: $issueId) {
+      ... on Issue {
+        repository {
+          milestone(number: $milestoneNumber) {
+            id
+          }
+        }
+      }
+    }
+  }
+`;
+var ISSUE_COMMENT_CREATE_MUTATION = `
+  mutation IssueCommentCreate($issueId: ID!, $body: String!) {
+    addComment(input: { subjectId: $issueId, body: $body }) {
+      commentEdge {
+        node {
+          id
+          body
+          url
+        }
+      }
+    }
+  }
+`;
+var ISSUE_LINKED_PRS_LIST_QUERY = `
+  query IssueLinkedPrsList($owner: String!, $name: String!, $issueNumber: Int!) {
+    repository(owner: $owner, name: $name) {
+      issue(number: $issueNumber) {
+        timelineItems(first: 50, itemTypes: [CONNECTED_EVENT]) {
+          nodes {
+            __typename
+            ... on ConnectedEvent {
+              subject {
+                __typename
+                ... on PullRequest {
+                  id
+                  number
+                  title
+                  state
+                  url
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var ISSUE_RELATIONS_GET_QUERY = `
+  query IssueRelationsGet($owner: String!, $name: String!, $issueNumber: Int!) {
+    repository(owner: $owner, name: $name) {
+      issue(number: $issueNumber) {
+        id
+        number
+        parent {
+          id
+          number
+        }
+        subIssues(first: 50) {
+          nodes {
+            id
+            number
+          }
+        }
+        blockedBy(first: 50) {
+          nodes {
+            id
+            number
+          }
+        }
+      }
+    }
+  }
+`;
+var ISSUE_PARENT_LOOKUP_QUERY = `
+  query IssueParentLookup($issueId: ID!) {
+    node(id: $issueId) {
+      ... on Issue {
+        id
+        parent {
+          id
+        }
+      }
+    }
+  }
+`;
+var ISSUE_PARENT_SET_MUTATION = `
+  mutation IssueParentSet($issueId: ID!, $parentIssueId: ID!) {
+    addSubIssue(input: { issueId: $parentIssueId, subIssueId: $issueId }) {
+      issue { id }
+      subIssue { id }
+    }
+  }
+`;
+var ISSUE_PARENT_REMOVE_MUTATION = `
+  mutation IssueParentRemove($issueId: ID!, $parentIssueId: ID!) {
+    removeSubIssue(input: { issueId: $parentIssueId, subIssueId: $issueId }) {
+      issue { id }
+      subIssue { id }
+    }
+  }
+`;
+var ISSUE_BLOCKED_BY_ADD_MUTATION = `
+  mutation IssueBlockedByAdd($issueId: ID!, $blockedByIssueId: ID!) {
+    addBlockedBy(input: { issueId: $issueId, blockingIssueId: $blockedByIssueId }) {
+      issue { id }
+      blockingIssue { id }
+    }
+  }
+`;
+var ISSUE_BLOCKED_BY_REMOVE_MUTATION = `
+  mutation IssueBlockedByRemove($issueId: ID!, $blockedByIssueId: ID!) {
+    removeBlockedBy(input: { issueId: $issueId, blockingIssueId: $blockedByIssueId }) {
+      issue { id }
+      blockingIssue { id }
+    }
+  }
+`;
+function createSdkClients(transport) {
+  const client = {
+    request(documentOrOptions, ...variablesAndRequestHeaders) {
+      const options = typeof documentOrOptions === "object" && documentOrOptions !== null && "document" in documentOrOptions ? documentOrOptions : {
+        document: documentOrOptions,
+        variables: variablesAndRequestHeaders[0]
+      };
+      const queryText = queryToString(options.document);
+      assertQuery(queryText);
+      return transport.execute(queryText, options.variables);
+    }
+  };
+  const graphqlRequestClient = client;
+  return {
+    issueCommentsList: getSdk(graphqlRequestClient),
+    issueList: getSdk2(graphqlRequestClient),
+    issue: getSdk3(graphqlRequestClient),
+    prDiffListFiles: getSdk4(graphqlRequestClient),
+    prList: getSdk5(graphqlRequestClient),
+    prReviewsList: getSdk6(graphqlRequestClient),
+    pr: getSdk7(graphqlRequestClient),
+    repo: getSdk8(graphqlRequestClient)
+  };
+}
+async function runRepoView(sdk, input) {
+  assertRepoInput(input);
+  const result = await sdk.RepoView(input);
+  if (!result.repository) {
+    throw new Error("Repository not found");
+  }
+  return {
+    id: result.repository.id,
+    name: result.repository.name,
+    nameWithOwner: result.repository.nameWithOwner,
+    isPrivate: result.repository.isPrivate,
+    stargazerCount: result.repository.stargazerCount,
+    forkCount: result.repository.forkCount,
+    url: result.repository.url,
+    defaultBranch: result.repository.defaultBranchRef?.name ?? null
+  };
+}
+async function runIssueView(sdk, input) {
+  assertIssueInput(input);
+  const result = await sdk.IssueView(input);
+  const issue = result.repository?.issue;
+  if (!issue) {
+    throw new Error("Issue not found");
+  }
+  return {
+    id: issue.id,
+    number: issue.number,
+    title: issue.title,
+    state: issue.state,
+    url: issue.url
+  };
+}
+async function runIssueList(sdk, input) {
+  assertIssueListInput(input);
+  const result = await sdk.IssueList(input);
+  const issues = result.repository?.issues;
+  if (!issues) {
+    throw new Error("Issues not found");
+  }
+  return {
+    items: (issues.nodes ?? []).flatMap(
+      (issue) => issue ? [
+        {
+          id: issue.id,
+          number: issue.number,
+          title: issue.title,
+          state: issue.state,
+          url: issue.url
+        }
+      ] : []
+    ),
+    pageInfo: {
+      endCursor: issues.pageInfo.endCursor ?? null,
+      hasNextPage: issues.pageInfo.hasNextPage
+    }
+  };
+}
+async function runIssueCommentsList(sdk, input) {
+  assertIssueCommentsListInput(input);
+  const result = await sdk.IssueCommentsList(input);
+  const comments = result.repository?.issue?.comments;
+  if (!comments) {
+    throw new Error("Issue comments not found");
+  }
+  return {
+    items: (comments.nodes ?? []).flatMap(
+      (comment) => comment ? [
+        {
+          id: comment.id,
+          body: comment.body,
+          authorLogin: comment.author?.login ?? null,
+          createdAt: comment.createdAt,
+          url: String(comment.url)
+        }
+      ] : []
+    ),
+    pageInfo: {
+      endCursor: comments.pageInfo.endCursor ?? null,
+      hasNextPage: comments.pageInfo.hasNextPage
+    }
+  };
+}
+function parseIssueNode(issue) {
+  const issueRecord = asRecord(issue);
+  if (!issueRecord || typeof issueRecord.id !== "string" || typeof issueRecord.number !== "number") {
+    throw new Error("Issue mutation failed");
+  }
+  const result = {
+    id: issueRecord.id,
+    number: issueRecord.number
+  };
+  if (typeof issueRecord.title === "string") {
+    result.title = issueRecord.title;
+  }
+  if (typeof issueRecord.state === "string") {
+    result.state = issueRecord.state;
+  }
+  if (typeof issueRecord.url === "string") {
+    result.url = issueRecord.url;
+  }
+  return result;
+}
+async function runIssueCreate(graphqlClient, input) {
+  assertIssueCreateInput(input);
+  const repositoryLookupResult = await graphqlClient.query(
+    ISSUE_CREATE_REPOSITORY_ID_QUERY,
+    {
+      owner: input.owner,
+      name: input.name
+    }
+  );
+  const repositoryId = asRecord(asRecord(repositoryLookupResult)?.repository)?.id;
+  if (typeof repositoryId !== "string" || repositoryId.length === 0) {
+    throw new Error("Repository not found");
+  }
+  const result = await graphqlClient.query(ISSUE_CREATE_MUTATION, {
+    repositoryId,
+    title: input.title,
+    body: input.body
+  });
+  const issue = asRecord(asRecord(result)?.createIssue)?.issue;
+  return parseIssueNode(issue);
+}
+async function runIssueUpdate(graphqlClient, input) {
+  assertIssueUpdateInput(input);
+  const result = await graphqlClient.query(ISSUE_UPDATE_MUTATION, {
+    issueId: input.issueId,
+    title: input.title,
+    body: input.body
+  });
+  const issue = asRecord(asRecord(result)?.updateIssue)?.issue;
+  return parseIssueNode(issue);
+}
+async function runIssueClose(graphqlClient, input) {
+  assertIssueMutationInput(input);
+  const result = await graphqlClient.query(ISSUE_CLOSE_MUTATION, {
+    issueId: input.issueId
+  });
+  const issueData = parseIssueNode(asRecord(asRecord(result)?.closeIssue)?.issue);
+  return {
+    ...issueData,
+    closed: issueData.state === "CLOSED"
+  };
+}
+async function runIssueReopen(graphqlClient, input) {
+  assertIssueMutationInput(input);
+  const result = await graphqlClient.query(ISSUE_REOPEN_MUTATION, {
+    issueId: input.issueId
+  });
+  const issueData = parseIssueNode(asRecord(asRecord(result)?.reopenIssue)?.issue);
+  return {
+    ...issueData,
+    reopened: issueData.state === "OPEN"
+  };
+}
+async function runIssueDelete(graphqlClient, input) {
+  assertIssueMutationInput(input);
+  const result = await graphqlClient.query(ISSUE_DELETE_MUTATION, {
+    issueId: input.issueId
+  });
+  const mutation = asRecord(asRecord(result)?.deleteIssue);
+  if (!mutation) {
+    throw new Error("Issue deletion failed");
+  }
+  return {
+    id: input.issueId,
+    number: 0,
+    deleted: true
+  };
+}
+async function runIssueLabelsUpdate(graphqlClient, input) {
+  assertIssueLabelsUpdateInput(input);
+  const lookupResult = await graphqlClient.query(
+    ISSUE_LABELS_LOOKUP_QUERY,
+    {
+      issueId: input.issueId
+    }
+  );
+  const availableLabels = Array.isArray(
+    asRecord(asRecord(asRecord(asRecord(lookupResult)?.node)?.repository)?.labels)?.nodes
+  ) ? asRecord(asRecord(asRecord(asRecord(lookupResult)?.node)?.repository)?.labels)?.nodes : [];
+  const labelIdsByName = /* @__PURE__ */ new Map();
+  for (const label of availableLabels) {
+    const labelRecord = asRecord(label);
+    if (typeof labelRecord?.name === "string" && typeof labelRecord?.id === "string") {
+      labelIdsByName.set(labelRecord.name.toLowerCase(), labelRecord.id);
+    }
+  }
+  const labelIds = input.labels.map((labelName) => {
+    const id = labelIdsByName.get(labelName.toLowerCase());
+    if (!id) {
+      throw new Error(`Label not found: ${labelName}`);
+    }
+    return id;
+  });
+  const result = await graphqlClient.query(
+    ISSUE_LABELS_UPDATE_MUTATION,
+    {
+      issueId: input.issueId,
+      labelIds
+    }
+  );
+  const mutation = asRecord(asRecord(result)?.["updateIssue"]);
+  const issue = asRecord(mutation?.["issue"]);
+  const labels = asRecord(issue?.["labels"]);
+  const labelNodes = Array.isArray(labels?.["nodes"]) ? labels["nodes"] : [];
+  return {
+    id: assertNonEmptyString(issue?.["id"], "Issue id"),
+    labels: labelNodes.map((label) => asRecord(label)?.["name"]).filter((name) => typeof name === "string")
+  };
+}
+async function runIssueAssigneesUpdate(graphqlClient, input) {
+  assertIssueAssigneesUpdateInput(input);
+  const lookupResult = await graphqlClient.query(
+    ISSUE_ASSIGNEES_LOOKUP_QUERY,
+    {
+      issueId: input.issueId
+    }
+  );
+  const availableAssignees = Array.isArray(
+    asRecord(asRecord(asRecord(asRecord(lookupResult)?.node)?.repository)?.assignableUsers)?.nodes
+  ) ? asRecord(asRecord(asRecord(asRecord(lookupResult)?.node)?.repository)?.assignableUsers)?.nodes : [];
+  const assigneeIdsByLogin = /* @__PURE__ */ new Map();
+  for (const assignee of availableAssignees) {
+    const assigneeRecord = asRecord(assignee);
+    if (typeof assigneeRecord?.login === "string" && typeof assigneeRecord?.id === "string") {
+      assigneeIdsByLogin.set(assigneeRecord.login.toLowerCase(), assigneeRecord.id);
+    }
+  }
+  const assigneeIds = input.assignees.map((login) => {
+    const id = assigneeIdsByLogin.get(login.toLowerCase());
+    if (!id) {
+      throw new Error(`Assignee not found: ${login}`);
+    }
+    return id;
+  });
+  const result = await graphqlClient.query(
+    ISSUE_ASSIGNEES_UPDATE_MUTATION,
+    {
+      issueId: input.issueId,
+      assigneeIds
+    }
+  );
+  const mutation = asRecord(asRecord(result)?.["updateIssue"]);
+  const issue = asRecord(mutation?.["issue"]);
+  const assignees = asRecord(issue?.["assignees"]);
+  const assigneeNodes = Array.isArray(assignees?.["nodes"]) ? assignees["nodes"] : [];
+  return {
+    id: assertNonEmptyString(issue?.["id"], "Issue id"),
+    assignees: assigneeNodes.map((assignee) => asRecord(assignee)?.["login"]).filter((login) => typeof login === "string")
+  };
+}
+async function runIssueMilestoneSet(graphqlClient, input) {
+  assertIssueMilestoneSetInput(input);
+  let milestoneId = null;
+  if (input.milestoneNumber !== null) {
+    const lookupResult = await graphqlClient.query(
+      ISSUE_MILESTONE_LOOKUP_QUERY,
+      {
+        issueId: input.issueId,
+        milestoneNumber: input.milestoneNumber
+      }
+    );
+    const resolvedId = asRecord(
+      asRecord(asRecord(asRecord(lookupResult)?.node)?.repository)?.milestone
+    )?.id;
+    if (typeof resolvedId !== "string" || resolvedId.length === 0) {
+      throw new Error(`Milestone not found: ${input.milestoneNumber}`);
+    }
+    milestoneId = resolvedId;
+  }
+  const result = await graphqlClient.query(
+    ISSUE_MILESTONE_SET_MUTATION,
+    {
+      issueId: input.issueId,
+      milestoneId
+    }
+  );
+  const mutation = asRecord(asRecord(result)?.["updateIssue"]);
+  const issue = asRecord(mutation?.["issue"]);
+  const milestone = asRecord(issue?.["milestone"]);
+  return {
+    id: assertNonEmptyString(issue?.["id"], "Issue id"),
+    milestoneNumber: typeof milestone?.["number"] === "number" ? milestone["number"] : null
+  };
+}
+async function runIssueCommentCreate(graphqlClient, input) {
+  assertIssueCommentCreateInput(input);
+  const result = await graphqlClient.query(
+    ISSUE_COMMENT_CREATE_MUTATION,
+    {
+      issueId: input.issueId,
+      body: input.body
+    }
+  );
+  const mutation = asRecord(asRecord(result)?.["addComment"]);
+  const commentEdge = asRecord(mutation?.["commentEdge"]);
+  const node = asRecord(commentEdge?.["node"]);
+  if (!node || typeof node["id"] !== "string" || typeof node["body"] !== "string") {
+    throw new Error("Issue comment creation failed");
+  }
+  return {
+    id: node["id"],
+    body: node["body"],
+    url: typeof node["url"] === "string" ? node["url"] : ""
+  };
+}
+async function runIssueLinkedPrsList(graphqlClient, input) {
+  assertIssueLinkedPrsListInput(input);
+  const result = await graphqlClient.query(ISSUE_LINKED_PRS_LIST_QUERY, {
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const issue = asRecord(asRecord(asRecord(result)?.repository)?.issue);
+  const timelineItems = asRecord(issue?.timelineItems);
+  const nodes = Array.isArray(timelineItems?.nodes) ? timelineItems.nodes : [];
+  return {
+    items: nodes.map((node) => asRecord(asRecord(node)?.["subject"])).filter(
+      (subject) => Boolean(subject) && subject?.["__typename"] === "PullRequest"
+    ).flatMap((subject) => {
+      if (!subject) {
+        return [];
+      }
+      if (typeof subject["id"] !== "string" || typeof subject["number"] !== "number" || typeof subject["title"] !== "string" || typeof subject["state"] !== "string" || typeof subject["url"] !== "string") {
+        return [];
+      }
+      return [
+        {
+          id: subject["id"],
+          number: subject["number"],
+          title: subject["title"],
+          state: subject["state"],
+          url: subject["url"]
+        }
+      ];
+    })
+  };
+}
+function parseIssueRelationNode(node) {
+  const record = asRecord(node);
+  if (!record || typeof record.id !== "string" || typeof record.number !== "number") {
+    return null;
+  }
+  return {
+    id: record.id,
+    number: record.number
+  };
+}
+async function runIssueRelationsGet(graphqlClient, input) {
+  assertIssueRelationsGetInput(input);
+  const result = await graphqlClient.query(ISSUE_RELATIONS_GET_QUERY, {
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const issue = asRecord(asRecord(asRecord(result)?.repository)?.issue);
+  const currentIssue = parseIssueRelationNode(issue);
+  if (!currentIssue) {
+    throw new Error("Issue relations not found");
+  }
+  const parent = parseIssueRelationNode(issue?.parent);
+  const subIssues = asRecord(issue?.["subIssues"]);
+  const blockedByConnection = asRecord(issue?.["blockedBy"]);
+  const childrenNodes = Array.isArray(subIssues?.["nodes"]) ? subIssues["nodes"] : [];
+  const blockedByNodes = Array.isArray(blockedByConnection?.["nodes"]) ? blockedByConnection["nodes"] : [];
+  return {
+    issue: currentIssue,
+    parent,
+    children: childrenNodes.map((node) => parseIssueRelationNode(node)).flatMap((node) => node ? [node] : []),
+    blockedBy: blockedByNodes.map((node) => parseIssueRelationNode(node)).flatMap((node) => node ? [node] : [])
+  };
+}
+async function runIssueParentSet(graphqlClient, input) {
+  assertIssueParentSetInput(input);
+  const result = await graphqlClient.query(ISSUE_PARENT_SET_MUTATION, {
+    issueId: input.issueId,
+    parentIssueId: input.parentIssueId
+  });
+  const mutation = asRecord(asRecord(result)?.addSubIssue);
+  const parentIssue = asRecord(mutation?.issue);
+  const subIssue = asRecord(mutation?.subIssue);
+  if (typeof parentIssue?.id !== "string" || typeof subIssue?.id !== "string") {
+    throw new Error("Issue parent update failed");
+  }
+  return {
+    issueId: subIssue.id,
+    parentIssueId: parentIssue.id
+  };
+}
+async function runIssueParentRemove(graphqlClient, input) {
+  assertIssueParentRemoveInput(input);
+  const lookupResult = await graphqlClient.query(
+    ISSUE_PARENT_LOOKUP_QUERY,
+    {
+      issueId: input.issueId
+    }
+  );
+  const parentIssueId = asRecord(asRecord(asRecord(lookupResult)?.node)?.parent)?.id;
+  if (typeof parentIssueId !== "string" || parentIssueId.length === 0) {
+    throw new Error("Issue parent removal failed");
+  }
+  const result = await graphqlClient.query(
+    ISSUE_PARENT_REMOVE_MUTATION,
+    {
+      issueId: input.issueId,
+      parentIssueId
+    }
+  );
+  const mutation = asRecord(asRecord(result)?.removeSubIssue);
+  const parentIssue = asRecord(mutation?.issue);
+  const subIssue = asRecord(mutation?.subIssue);
+  if (typeof parentIssue?.id !== "string" || typeof subIssue?.id !== "string") {
+    throw new Error("Issue parent removal failed");
+  }
+  return {
+    issueId: subIssue.id,
+    parentRemoved: true
+  };
+}
+async function runIssueBlockedByAdd(graphqlClient, input) {
+  assertIssueBlockedByInput(input);
+  const result = await graphqlClient.query(
+    ISSUE_BLOCKED_BY_ADD_MUTATION,
+    {
+      issueId: input.issueId,
+      blockedByIssueId: input.blockedByIssueId
+    }
+  );
+  const mutation = asRecord(asRecord(result)?.addBlockedBy);
+  const issue = asRecord(mutation?.issue);
+  const blockingIssue = asRecord(mutation?.blockingIssue);
+  if (typeof issue?.id !== "string" || typeof blockingIssue?.id !== "string") {
+    throw new Error("Issue dependency mutation failed");
+  }
+  return {
+    issueId: issue.id,
+    blockedByIssueId: blockingIssue.id
+  };
+}
+async function runIssueBlockedByRemove(graphqlClient, input) {
+  assertIssueBlockedByInput(input);
+  const result = await graphqlClient.query(
+    ISSUE_BLOCKED_BY_REMOVE_MUTATION,
+    {
+      issueId: input.issueId,
+      blockedByIssueId: input.blockedByIssueId
+    }
+  );
+  const mutation = asRecord(asRecord(result)?.removeBlockedBy);
+  const issue = asRecord(mutation?.issue);
+  const blockingIssue = asRecord(mutation?.blockingIssue);
+  if (typeof issue?.id !== "string" || typeof blockingIssue?.id !== "string") {
+    throw new Error("Issue dependency mutation failed");
+  }
+  return {
+    issueId: issue.id,
+    blockedByIssueId: blockingIssue.id,
+    removed: true
+  };
+}
+async function runPrView(sdk, input) {
+  assertPrInput(input);
+  const result = await sdk.PrView(input);
+  const pr = result.repository?.pullRequest;
+  if (!pr) {
+    throw new Error("Pull request not found");
+  }
+  return {
+    id: pr.id,
+    number: pr.number,
+    title: pr.title,
+    state: pr.state,
+    url: pr.url
+  };
+}
+async function runPrList(sdk, input) {
+  assertPrListInput(input);
+  const result = await sdk.PrList(input);
+  const prs = result.repository?.pullRequests;
+  if (!prs) {
+    throw new Error("Pull requests not found");
+  }
+  return {
+    items: (prs.nodes ?? []).flatMap(
+      (pr) => pr ? [
+        {
+          id: pr.id,
+          number: pr.number,
+          title: pr.title,
+          state: pr.state,
+          url: pr.url
+        }
+      ] : []
+    ),
+    pageInfo: {
+      endCursor: prs.pageInfo.endCursor ?? null,
+      hasNextPage: prs.pageInfo.hasNextPage
+    }
+  };
+}
+async function runPrReviewsList(sdk, input) {
+  assertPrReviewsListInput(input);
+  const result = await sdk.PrReviewsList(input);
+  const reviews = result.repository?.pullRequest?.reviews;
+  if (!reviews) {
+    throw new Error("Pull request reviews not found");
+  }
+  return {
+    items: (reviews.nodes ?? []).flatMap(
+      (review) => review ? [
+        {
+          id: review.id,
+          authorLogin: review.author?.login ?? null,
+          body: review.body,
+          state: review.state,
+          submittedAt: review.submittedAt ?? null,
+          url: review.url,
+          commitOid: review.commit?.oid ?? null
+        }
+      ] : []
+    ),
+    pageInfo: {
+      endCursor: reviews.pageInfo.endCursor ?? null,
+      hasNextPage: reviews.pageInfo.hasNextPage
+    }
+  };
+}
+async function runPrDiffListFiles(sdk, input) {
+  assertPrDiffListFilesInput(input);
+  const result = await sdk.PrDiffListFiles(input);
+  const files = result.repository?.pullRequest?.files;
+  if (!files) {
+    throw new Error("Pull request files not found");
+  }
+  return {
+    items: (files.nodes ?? []).flatMap(
+      (file) => file ? [
+        {
+          path: file.path,
+          additions: file.additions,
+          deletions: file.deletions
+        }
+      ] : []
+    ),
+    pageInfo: {
+      endCursor: files.pageInfo.endCursor ?? null,
+      hasNextPage: files.pageInfo.hasNextPage
+    }
+  };
+}
+var MAX_PR_REVIEW_THREAD_SCAN_PAGES = 5;
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function normalizePrReviewThreadComment(comment) {
+  const commentRecord = asRecord(comment);
+  if (!commentRecord || typeof commentRecord.id !== "string") {
+    return null;
+  }
+  const author = asRecord(commentRecord.author);
+  const url = commentRecord.url;
+  return {
+    id: commentRecord.id,
+    authorLogin: typeof author?.login === "string" ? author.login : null,
+    body: typeof commentRecord.body === "string" ? commentRecord.body : "",
+    createdAt: typeof commentRecord.createdAt === "string" ? commentRecord.createdAt : "",
+    url: typeof url === "string" ? url : String(url ?? "")
+  };
+}
+function normalizePrReviewThread(thread) {
+  const threadRecord = asRecord(thread);
+  if (!threadRecord || typeof threadRecord.id !== "string") {
+    return null;
+  }
+  const comments = asRecord(threadRecord.comments);
+  const commentNodes = Array.isArray(comments?.nodes) ? comments.nodes : [];
+  const resolvedBy = asRecord(threadRecord.resolvedBy);
+  return {
+    id: threadRecord.id,
+    path: typeof threadRecord.path === "string" ? threadRecord.path : null,
+    line: typeof threadRecord.line === "number" ? threadRecord.line : null,
+    startLine: typeof threadRecord.startLine === "number" ? threadRecord.startLine : null,
+    diffSide: typeof threadRecord.diffSide === "string" ? threadRecord.diffSide : null,
+    subjectType: typeof threadRecord.subjectType === "string" ? threadRecord.subjectType : null,
+    isResolved: Boolean(threadRecord.isResolved),
+    isOutdated: Boolean(threadRecord.isOutdated),
+    viewerCanReply: Boolean(threadRecord.viewerCanReply),
+    viewerCanResolve: Boolean(threadRecord.viewerCanResolve),
+    viewerCanUnresolve: Boolean(threadRecord.viewerCanUnresolve),
+    resolvedByLogin: typeof resolvedBy?.login === "string" ? resolvedBy.login : null,
+    comments: commentNodes.map((comment) => normalizePrReviewThreadComment(comment)).flatMap((comment) => comment ? [comment] : [])
+  };
+}
+async function runPrCommentsList(graphqlClient, input) {
+  assertPrCommentsListInput(input);
+  const unresolvedOnly = input.unresolvedOnly ?? false;
+  const includeOutdated = input.includeOutdated ?? true;
+  const filteredThreads = [];
+  let sourceEndCursor = input.after ?? null;
+  let sourceHasNextPage = false;
+  let pagesScanned = 0;
+  let sourceItemsScanned = 0;
+  while (pagesScanned < MAX_PR_REVIEW_THREAD_SCAN_PAGES && filteredThreads.length < input.first) {
+    const result = await graphqlClient.query(PR_COMMENTS_LIST_QUERY, {
+      owner: input.owner,
+      name: input.name,
+      prNumber: input.prNumber,
+      first: input.first,
+      after: sourceEndCursor
+    });
+    const repository = asRecord(asRecord(result)?.repository);
+    const pullRequest = asRecord(repository?.pullRequest);
+    const reviewThreads = asRecord(pullRequest?.reviewThreads);
+    if (!reviewThreads) {
+      throw new Error("Pull request review threads not found");
+    }
+    const pageInfo = asRecord(reviewThreads.pageInfo);
+    const threadEdges = Array.isArray(reviewThreads.edges) ? reviewThreads.edges.map((edge) => {
+      const edgeRecord = asRecord(edge);
+      if (!edgeRecord) {
+        return null;
+      }
+      return {
+        cursor: typeof edgeRecord.cursor === "string" ? edgeRecord.cursor : null,
+        node: edgeRecord.node
+      };
+    }).flatMap((edge) => edge ? [edge] : []) : [];
+    const threadNodes = threadEdges.length > 0 ? threadEdges : Array.isArray(reviewThreads.nodes) ? reviewThreads.nodes.map((node) => ({ cursor: null, node })) : [];
+    pagesScanned += 1;
+    sourceItemsScanned += threadNodes.length;
+    for (const threadNode of threadNodes) {
+      const normalized = normalizePrReviewThread(threadNode.node);
+      if (!normalized) {
+        continue;
+      }
+      if (unresolvedOnly && normalized.isResolved) {
+        continue;
+      }
+      if (unresolvedOnly && !includeOutdated && normalized.isOutdated) {
+        continue;
+      }
+      filteredThreads.push({ thread: normalized, cursor: threadNode.cursor });
+    }
+    sourceHasNextPage = Boolean(pageInfo?.hasNextPage);
+    sourceEndCursor = typeof pageInfo?.endCursor === "string" ? pageInfo.endCursor : null;
+    if (!sourceHasNextPage) {
+      break;
+    }
+  }
+  const hasBufferedFilteredItems = filteredThreads.length > input.first;
+  const returnedThreads = filteredThreads.slice(0, input.first);
+  const endCursor = returnedThreads.length > 0 ? returnedThreads[returnedThreads.length - 1]?.cursor ?? sourceEndCursor : sourceEndCursor;
+  const scanTruncated = sourceHasNextPage && pagesScanned >= MAX_PR_REVIEW_THREAD_SCAN_PAGES;
+  return {
+    items: returnedThreads.map((entry) => entry.thread),
+    pageInfo: {
+      hasNextPage: hasBufferedFilteredItems || sourceHasNextPage,
+      endCursor: hasBufferedFilteredItems || sourceHasNextPage ? endCursor : null
+    },
+    filterApplied: {
+      unresolvedOnly,
+      includeOutdated
+    },
+    scan: {
+      pagesScanned,
+      sourceItemsScanned,
+      scanTruncated
+    }
+  };
+}
+function assertReviewThreadInput(input) {
+  if (typeof input.threadId !== "string" || input.threadId.trim().length === 0) {
+    throw new Error("Review thread id is required");
+  }
+}
+function assertReplyToReviewThreadInput(input) {
+  assertReviewThreadInput(input);
+  if (typeof input.body !== "string" || input.body.trim().length === 0) {
+    throw new Error("Reply body is required");
+  }
+}
+function parseReviewThreadMutationResult(result, mutationKey) {
+  const root = asRecord(result);
+  const mutation = asRecord(root?.[mutationKey]);
+  const thread = asRecord(mutation?.thread);
+  if (!thread || typeof thread.id !== "string") {
+    throw new Error("Review thread mutation failed");
+  }
+  return {
+    id: thread.id,
+    isResolved: Boolean(thread.isResolved)
+  };
+}
+async function runReplyToReviewThread(graphqlClient, input) {
+  assertReplyToReviewThreadInput(input);
+  const result = await graphqlClient.query(PR_COMMENT_REPLY_MUTATION, {
+    threadId: input.threadId,
+    body: input.body
+  });
+  const root = asRecord(result);
+  const mutation = asRecord(root?.addPullRequestReviewThreadReply);
+  const comment = asRecord(mutation?.comment);
+  if (!comment || typeof comment.id !== "string") {
+    throw new Error("Review thread mutation failed");
+  }
+  const threadStateResult = await graphqlClient.query(
+    REVIEW_THREAD_STATE_QUERY,
+    {
+      threadId: input.threadId
+    }
+  );
+  const threadNode = asRecord(asRecord(threadStateResult)?.node);
+  if (!threadNode || typeof threadNode.id !== "string") {
+    throw new Error("Review thread state lookup failed");
+  }
+  return {
+    id: input.threadId,
+    isResolved: Boolean(threadNode.isResolved)
+  };
+}
+async function runResolveReviewThread(graphqlClient, input) {
+  assertReviewThreadInput(input);
+  const result = await graphqlClient.query(PR_COMMENT_RESOLVE_MUTATION, {
+    threadId: input.threadId
+  });
+  return parseReviewThreadMutationResult(result, "resolveReviewThread");
+}
+async function runUnresolveReviewThread(graphqlClient, input) {
+  assertReviewThreadInput(input);
+  const result = await graphqlClient.query(
+    PR_COMMENT_UNRESOLVE_MUTATION,
+    {
+      threadId: input.threadId
+    }
+  );
+  return parseReviewThreadMutationResult(result, "unresolveReviewThread");
+}
+function queryToString(query) {
+  if (typeof query === "string") {
+    return query;
+  }
+  if (typeof query === "object" && query !== null && "kind" in query) {
+    return print(query);
+  }
+  return String(query);
+}
+function assertQuery(query) {
+  if (query.trim().length === 0) {
+    throw new Error("GraphQL query must be non-empty");
+  }
+}
+function createGraphqlClient(transport) {
+  return {
+    async query(query, variables) {
+      const queryText = queryToString(query);
+      assertQuery(queryText);
+      return transport.execute(queryText, variables);
+    }
+  };
+}
+var DEFAULT_GRAPHQL_URL = "https://api.github.com/graphql";
+function resolveGraphqlUrl() {
+  if (process.env.GITHUB_GRAPHQL_URL) {
+    return process.env.GITHUB_GRAPHQL_URL;
+  }
+  if (process.env.GH_HOST) {
+    return `https://${process.env.GH_HOST}/api/graphql`;
+  }
+  return DEFAULT_GRAPHQL_URL;
+}
+function createTokenTransport(token, graphqlUrl) {
+  const url = graphqlUrl ?? resolveGraphqlUrl();
+  return {
+    async execute(query, variables) {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify({ query, variables: variables ?? {} })
+      });
+      const payload = await response.json();
+      if (!response.ok) {
+        throw new Error(payload.message ?? `GraphQL request failed (${response.status})`);
+      }
+      if (payload.errors?.length) {
+        throw new Error(payload.errors[0]?.message ?? "GraphQL returned errors");
+      }
+      if (payload.data === void 0) {
+        throw new Error("GraphQL response missing data");
+      }
+      return payload.data;
+    }
+  };
+}
+function createGithubClientFromToken(tokenOrOptions) {
+  const token = typeof tokenOrOptions === "string" ? tokenOrOptions : tokenOrOptions.token;
+  const graphqlUrl = typeof tokenOrOptions === "string" ? void 0 : tokenOrOptions.graphqlUrl;
+  if (!token || token.trim().length === 0) {
+    throw new Error("GitHub token is required");
+  }
+  return createGithubClient(createTokenTransport(token, graphqlUrl));
+}
+function createGithubClient(transport) {
+  const graphqlClient = createGraphqlClient(transport);
+  const sdk = createSdkClients(transport);
+  return {
+    query: (query, variables) => graphqlClient.query(query, variables),
+    fetchRepoView: (input) => runRepoView(sdk.repo, input),
+    fetchIssueCommentsList: (input) => runIssueCommentsList(sdk.issueCommentsList, input),
+    createIssue: (input) => runIssueCreate(graphqlClient, input),
+    updateIssue: (input) => runIssueUpdate(graphqlClient, input),
+    closeIssue: (input) => runIssueClose(graphqlClient, input),
+    reopenIssue: (input) => runIssueReopen(graphqlClient, input),
+    deleteIssue: (input) => runIssueDelete(graphqlClient, input),
+    updateIssueLabels: (input) => runIssueLabelsUpdate(graphqlClient, input),
+    updateIssueAssignees: (input) => runIssueAssigneesUpdate(graphqlClient, input),
+    setIssueMilestone: (input) => runIssueMilestoneSet(graphqlClient, input),
+    createIssueComment: (input) => runIssueCommentCreate(graphqlClient, input),
+    fetchIssueLinkedPrs: (input) => runIssueLinkedPrsList(graphqlClient, input),
+    fetchIssueRelations: (input) => runIssueRelationsGet(graphqlClient, input),
+    setIssueParent: (input) => runIssueParentSet(graphqlClient, input),
+    removeIssueParent: (input) => runIssueParentRemove(graphqlClient, input),
+    addIssueBlockedBy: (input) => runIssueBlockedByAdd(graphqlClient, input),
+    removeIssueBlockedBy: (input) => runIssueBlockedByRemove(graphqlClient, input),
+    fetchIssueList: (input) => runIssueList(sdk.issueList, input),
+    fetchIssueView: (input) => runIssueView(sdk.issue, input),
+    fetchPrList: (input) => runPrList(sdk.prList, input),
+    fetchPrView: (input) => runPrView(sdk.pr, input),
+    fetchPrCommentsList: (input) => runPrCommentsList(graphqlClient, input),
+    fetchPrReviewsList: (input) => runPrReviewsList(sdk.prReviewsList, input),
+    fetchPrDiffListFiles: (input) => runPrDiffListFiles(sdk.prDiffListFiles, input),
+    replyToReviewThread: (input) => runReplyToReviewThread(graphqlClient, input),
+    resolveReviewThread: (input) => runResolveReviewThread(graphqlClient, input),
+    unresolveReviewThread: (input) => runUnresolveReviewThread(graphqlClient, input)
+  };
+}
+
+export {
+  createSafeCliCommandRunner,
+  errorCodes,
+  executeTask,
+  createGraphqlClient,
+  createGithubClientFromToken,
+  createGithubClient
+};
+//# sourceMappingURL=chunk-RDUPMVHG.js.map