@ghx-dev/core 0.2.0 → 0.2.1

package/dist/{chunk-3P3KHWFU.js → chunk-M5PJLKL5.js}

@@ -1,3 +1,22 @@
+import {
+  AddProjectV2ItemDocument,
+  ProjectV2FieldsListOrgDocument,
+  ProjectV2ItemsListOrgDocument,
+  ProjectV2OrgViewDocument,
+  ProjectV2UserViewDocument,
+  RemoveProjectV2ItemDocument,
+  UpdateProjectV2ItemFieldDocument
+} from "./chunk-H7CLZHRO.js";
+import {
+  RepoIssueTypesListDocument,
+  RepoLabelsListDocument,
+  RepoViewDocument
+} from "./chunk-NQ53ETYV.js";
+import {
+  IssueCommentsListDocument,
+  IssueListDocument,
+  IssueViewDocument
+} from "./chunk-TGL33GEA.js";
 import {
   IssueAssigneesAddDocument,
   IssueAssigneesLookupByNumberDocument,
@@ -8,27 +27,52 @@ import {
   IssueCloseDocument,
   IssueCommentCreateDocument,
   IssueCreateDocument,
-  IssueCreateRepositoryIdDocument,
   IssueDeleteDocument,
   IssueLabelsAddDocument,
   IssueLabelsLookupByNumberDocument,
+  IssueLabelsRemoveDocument,
   IssueLabelsUpdateDocument,
+  IssueLinkedPrsListDocument,
   IssueMilestoneLookupByNumberDocument,
   IssueMilestoneSetDocument,
   IssueNodeIdLookupDocument,
   IssueParentLookupDocument,
   IssueParentRemoveDocument,
   IssueParentSetDocument,
+  IssueRelationsGetDocument,
   IssueReopenDocument,
   IssueUpdateDocument
-} from "./chunk-Q7RCIK2C.js";
+} from "./chunk-Q2NW7DJE.js";
+import {
+  PrDiffListFilesDocument,
+  PrListDocument,
+  PrMergeStatusDocument,
+  PrReviewsListDocument,
+  PrViewDocument
+} from "./chunk-QRHKAMRY.js";
 import {
+  PrAssigneesAddDocument,
+  PrAssigneesRemoveDocument,
+  PrBranchUpdateDocument,
   PrCommentReplyDocument,
   PrCommentResolveDocument,
   PrCommentUnresolveDocument,
+  PrCommentsListDocument,
+  PrCreateDocument,
+  PrMergeDocument,
   PrNodeIdDocument,
-  PrReviewSubmitDocument
-} from "./chunk-TDABI6C7.js";
+  PrReviewSubmitDocument,
+  PrReviewsRequestDocument,
+  PrUpdateDocument,
+  UserNodeIdDocument
+} from "./chunk-7HUKYNI2.js";
+import {
+  IssueCreateRepositoryIdDocument
+} from "./chunk-ZGBVX2VG.js";
+import {
+  ReleaseListDocument,
+  ReleaseViewDocument
+} from "./chunk-GQO6BHJV.js";
 import {
   createGraphqlClient,
   createTokenTransport
@@ -188,9 +232,10 @@ var operationCardSchema = {
     },
     graphql: {
       type: "object",
-      required: ["operationName", "documentPath"],
+      required: ["operationName", "operationType", "documentPath"],
       properties: {
         operationName: { type: "string", minLength: 1 },
+        operationType: { enum: ["query", "mutation"] },
         documentPath: { type: "string", minLength: 1 },
         variables: { type: "object" },
         limits: {
@@ -616,111 +661,6 @@ var errorCodes = {
   Unknown: "UNKNOWN"
 };
 
-// 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("operation not available")) {
-    return errorCodes.AdapterUnsupported;
-  }
-  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/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/log.ts
 import * as fs from "fs";
 import * as os from "os";
@@ -805,7 +745,7 @@ function createLogger(config) {
   }
   function write(level, msg, ctx) {
     if (levelIndex(level) < minIndex) return;
-    const version = true ? "0.2.0" : "unknown";
+    const version = true ? "0.2.1" : "unknown";
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       pid: config.pid,
@@ -831,68 +771,291 @@ function createLogger(config) {
 }
 var logger = createLogger(createLoggerConfig());
 
-// src/core/execute/execute.ts
-function parsePredicateValue(raw) {
-  const value = raw.trim();
-  if (value === "true") {
-    return true;
+// src/core/errors/map-error.ts
+function toMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
   }
-  if (value === "false") {
-    return false;
+  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 (value === "null") {
-    return null;
+  if (/\b(500|502|503|504)\b/.test(message)) {
+    return errorCodes.Server;
   }
-  const numeric = Number(value);
-  if (!Number.isNaN(numeric) && value.length > 0) {
-    return numeric;
+  if (message.includes("timeout")) {
+    return errorCodes.Network;
   }
-  return value.replace(/^['"]|['"]$/g, "");
-}
-function resolvePathValue(source, path2) {
-  const segments = path2.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];
+  if (message.includes("econn") || message.includes("enotfound") || message.includes("eai_again") || message.includes("network") || message.includes("connection reset")) {
+    return errorCodes.Network;
   }
-  return current;
+  if (message.includes("not found") || /\b404\b/.test(message)) {
+    return errorCodes.NotFound;
+  }
+  if (message.includes("operation not available")) {
+    return errorCodes.AdapterUnsupported;
+  }
+  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;
 }
-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();
+
+// src/core/routing/engine/assemble.ts
+function isRetryableCode(code) {
+  return code === errorCodes.RateLimit || code === errorCodes.Network || code === errorCodes.Server;
+}
+function assembleChainResult(input) {
+  const {
+    steps,
+    requests,
+    mutationRawResult,
+    queryRawResult,
+    stepErrors,
+    cliResults,
+    cliStepCount,
+    batchStartMs
+  } = input;
+  const mutationStepIndices = new Set(
+    steps.filter((s) => s.route === "gql-mutation").map((s) => s.index)
+  );
+  const results = requests.map((req, stepIndex) => {
+    if (req === void 0) {
+      throw new Error(`invariant violated: request at index ${stepIndex} is undefined`);
     }
-    const conditionalMatch = /^(cli|graphql|rest)\s+if\s+([a-zA-Z0-9_.]+)\s*(==|!=)\s*(.+)$/i.exec(
-      rule.predicate.trim()
-    );
-    if (!conditionalMatch) {
-      continue;
+    const cliResult = cliResults.get(stepIndex);
+    if (cliResult !== void 0) {
+      return cliResult.ok ? { task: req.task, ok: true, data: cliResult.data } : {
+        task: req.task,
+        ok: false,
+        error: cliResult.error ?? {
+          code: errorCodes.Unknown,
+          message: "CLI step failed",
+          retryable: false
+        }
+      };
     }
-    const [, targetRouteRaw = "", rawPath = "", operator = "==", rawExpected = ""] = conditionalMatch;
-    const targetRoute = targetRouteRaw.toLowerCase();
-    const source = rule.when === "env" ? routingContext : params;
-    const path2 = rawPath.startsWith("params.") || rawPath.startsWith("env.") ? rawPath.split(".").slice(1).join(".") : rawPath;
-    const actual = resolvePathValue(source, path2);
-    const expected = parsePredicateValue(rawExpected);
-    const matches = operator === "==" ? actual === expected : actual !== expected;
-    if (matches) {
-      return targetRoute;
+    const alias = `step${stepIndex}`;
+    const stepError = stepErrors.get(alias);
+    if (stepError !== void 0) {
+      const code = mapErrorToCode(stepError);
+      return {
+        task: req.task,
+        ok: false,
+        error: {
+          code,
+          message: stepError,
+          retryable: isRetryableCode(code)
+        }
+      };
     }
-  }
-  return card.routing.preferred;
+    if (alias in mutationRawResult) {
+      return { task: req.task, ok: true, data: mutationRawResult[alias] };
+    }
+    if (alias in queryRawResult) {
+      return { task: req.task, ok: true, data: queryRawResult[alias] };
+    }
+    const missingMsg = mutationStepIndices.has(stepIndex) ? `missing mutation result for alias ${alias}` : `missing result for alias ${alias}`;
+    return {
+      task: req.task,
+      ok: false,
+      error: {
+        code: errorCodes.Unknown,
+        message: missingMsg,
+        retryable: false
+      }
+    };
+  });
+  const succeeded = results.filter((r) => r.ok).length;
+  const status = succeeded === results.length ? "success" : succeeded === 0 ? "failed" : "partial";
+  logger.info("execute_batch.complete", {
+    ok: status !== "failed",
+    status,
+    total: results.length,
+    succeeded,
+    failed: results.length - succeeded,
+    duration_ms: Date.now() - batchStartMs
+  });
+  const routeUsed = cliStepCount === requests.length ? "cli" : "graphql";
+  return {
+    status,
+    results,
+    meta: {
+      route_used: routeUsed,
+      total: results.length,
+      succeeded,
+      failed: results.length - succeeded
+    }
+  };
 }
-function routePlan(card, params, routingContext) {
-  const preferred = evaluateSuitabilityPreferred(card, params, routingContext);
-  const planned = /* @__PURE__ */ new Set([preferred, ...card.routing.fallbacks]);
-  return [...planned];
+function assembleResolutionFailure(requests, steps, phase1Error, cliResults) {
+  const cliStepCount = steps.filter((s) => s.route === "cli").length;
+  const results = requests.map((req, i) => {
+    if (req === void 0) {
+      throw new Error(`invariant violated: request at index ${i} is undefined`);
+    }
+    const cliResult = cliResults.get(i);
+    if (cliResult !== void 0) {
+      return cliResult.ok ? { task: req.task, ok: true, data: cliResult.data } : {
+        task: req.task,
+        ok: false,
+        error: cliResult.error ?? {
+          code: errorCodes.Unknown,
+          message: "CLI step failed",
+          retryable: false
+        }
+      };
+    }
+    return { task: req.task, ok: false, error: phase1Error };
+  });
+  const succeeded = results.filter((r) => r.ok).length;
+  const total = results.length;
+  const status = succeeded === total ? "success" : succeeded === 0 ? "failed" : "partial";
+  const routeUsed = cliStepCount === requests.length ? "cli" : "graphql";
+  return {
+    status,
+    results,
+    meta: { route_used: routeUsed, total, succeeded, failed: total - succeeded }
+  };
 }
-async function execute(options) {
+
+// 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/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, path2) {
+  const segments = path2.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 path2 = rawPath.startsWith("params.") || rawPath.startsWith("env.") ? rawPath.split(".").slice(1).join(".") : rawPath;
+    const actual = resolvePathValue(source, path2);
+    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(
@@ -2135,6 +2298,7 @@ var handlePrMerge = async (runner, params, card) => {
       {
         prNumber: Number(params.prNumber),
         method: method === "squash" || method === "rebase" ? method : "merge",
+        isMethodAssumed: params.method === void 0,
         queued: true,
         deleteBranch: params.deleteBranch === true
       },
@@ -2835,7 +2999,7 @@ var handleProjectV2ItemAddIssue = async (runner, params, _card) => {
     }
     const data = parseCliData(result.stdout);
     const root = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
-    const normalized = { itemId: typeof root.id === "string" ? root.id : null, added: true };
+    const normalized = { itemId: typeof root.id === "string" ? root.id : null, itemType: null };
     return normalizeResult(normalized, "cli", {
       capabilityId: "project_v2.items.issue.add",
       reason: "CARD_FALLBACK"
@@ -2925,7 +3089,7 @@ var handleProjectV2ItemFieldUpdate = async (runner, params, _card) => {
         { capabilityId: "project_v2.items.field.update", reason: "CARD_FALLBACK" }
       );
     }
-    const normalized = { itemId, updated: true };
+    const normalized = { itemId };
     return normalizeResult(normalized, "cli", {
       capabilityId: "project_v2.items.field.update",
       reason: "CARD_FALLBACK"
@@ -2968,7 +3132,7 @@ var handleProjectV2ItemsIssueRemove = async (runner, params, _card) => {
         { capabilityId: "project_v2.items.issue.remove", reason: "CARD_FALLBACK" }
       );
     }
-    const normalized = { itemId, removed: true };
+    const normalized = { deletedItemId: itemId };
     return normalizeResult(normalized, "cli", {
       capabilityId: "project_v2.items.issue.remove",
       reason: "CARD_FALLBACK"
@@ -4572,6 +4736,15 @@ var handlers7 = /* @__PURE__ */ new Map([
       return c.updateIssueLabels(p);
     }
   ],
+  [
+    "issue.labels.remove",
+    (c, p) => {
+      if (!c.removeIssueLabels) {
+        throw new Error("removeIssueLabels operation not available");
+      }
+      return c.removeIssueLabels(p);
+    }
+  ],
   [
     "issue.assignees.set",
     (c, p) => {
@@ -4608,6 +4781,15 @@ var handlers7 = /* @__PURE__ */ new Map([
       return c.setIssueMilestone(p);
     }
   ],
+  [
+    "issue.milestone.clear",
+    (c, p) => {
+      if (!c.clearIssueMilestone) {
+        throw new Error("clearIssueMilestone operation not available");
+      }
+      return c.clearIssueMilestone(p);
+    }
+  ],
   [
     "issue.comments.create",
     (c, p) => {
@@ -4709,6 +4891,80 @@ var handlers7 = /* @__PURE__ */ new Map([
       }
       return c.submitPrReview(p);
     }
+  ],
+  ["repo.labels.list", (c, p) => c.fetchRepoLabelsList(withDefaultFirst(p))],
+  [
+    "repo.issue_types.list",
+    (c, p) => c.fetchRepoIssueTypesList(withDefaultFirst(p))
+  ],
+  // Release
+  ["release.view", (c, p) => c.fetchReleaseView(p)],
+  ["release.list", (c, p) => c.fetchReleaseList(withDefaultFirst(p))],
+  // Project V2
+  ["project_v2.org.view", (c, p) => c.fetchProjectV2OrgView(p)],
+  ["project_v2.user.view", (c, p) => c.fetchProjectV2UserView(p)],
+  [
+    "project_v2.fields.list",
+    (c, p) => c.fetchProjectV2FieldsList(withDefaultFirst(p))
+  ],
+  [
+    "project_v2.items.list",
+    (c, p) => c.fetchProjectV2ItemsList(withDefaultFirst(p))
+  ],
+  // PR mutations (Phase 2)
+  [
+    "pr.create",
+    (c, p) => {
+      const raw = p;
+      return c.createPr({
+        owner: raw.owner,
+        name: raw.name,
+        title: raw.title,
+        headRefName: raw.head,
+        baseRefName: raw.base,
+        ...raw.body !== void 0 ? { body: raw.body } : {},
+        ...raw.draft !== void 0 ? { draft: raw.draft } : {}
+      });
+    }
+  ],
+  ["pr.update", (c, p) => c.updatePr(p)],
+  [
+    "pr.merge",
+    (c, p) => {
+      const raw = p;
+      const methodMap = {
+        merge: "MERGE",
+        squash: "SQUASH",
+        rebase: "REBASE"
+      };
+      if (raw.method !== void 0 && typeof raw.method !== "string") {
+        throw new Error(`method must be a string for pr.merge, got ${typeof raw.method}`);
+      }
+      const mergeMethod = raw.method !== void 0 ? methodMap[raw.method.toLowerCase()] : void 0;
+      if (raw.method !== void 0 && !mergeMethod) {
+        throw new Error(
+          `Unsupported merge method "${raw.method}" for pr.merge. Expected one of: merge, squash, rebase.`
+        );
+      }
+      return c.mergePr({
+        owner: raw.owner,
+        name: raw.name,
+        prNumber: raw.prNumber,
+        ...mergeMethod !== void 0 ? { mergeMethod } : {},
+        ...raw.deleteBranch !== void 0 ? { deleteBranch: raw.deleteBranch } : {}
+      });
+    }
+  ],
+  ["pr.branch.update", (c, p) => c.updatePrBranch(p)],
+  ["pr.assignees.add", (c, p) => c.addPrAssignees(p)],
+  ["pr.assignees.remove", (c, p) => c.removePrAssignees(p)],
+  ["pr.reviews.request", (c, p) => c.requestPrReviews(p)],
+  // Project V2 mutations (Phase 2)
+  ["project_v2.items.issue.add", (c, p) => c.addProjectV2Item(p)],
+  ["project_v2.items.issue.remove", (c, p) => c.removeProjectV2Item(p)],
+  [
+    "project_v2.items.field.update",
+    (c, p) => c.updateProjectV2ItemField(p)
   ]
 ]);
 function getGraphqlHandler(capabilityId) {
@@ -4797,81 +5053,263 @@ function preflightCheck(input) {
 // src/core/routing/policy.ts
 var routePreferenceOrder = ["cli", "graphql"];
 
-// src/gql/batch.ts
-function extractRootFieldName(query) {
-  const headerEnd = query.indexOf("{");
-  if (headerEnd === -1) return null;
-  const body = query.slice(headerEnd + 1);
-  const match = body.match(/^\s*(\w+)/);
-  return match?.[1] ?? null;
-}
-function buildBatchMutation(operations) {
-  if (operations.length === 0) {
-    throw new Error("buildBatchMutation requires at least one operation");
-  }
-  const allVarDeclarations = [];
-  const allSelections = [];
-  const mergedVariables = {};
-  const allFragments = /* @__PURE__ */ new Map();
-  for (const op of operations) {
-    const parsed = parseOperation(op.mutation);
-    for (const [name, text] of parsed.fragments) {
-      if (!allFragments.has(name)) {
-        allFragments.set(name, text);
-      }
-    }
-    for (const varDecl of parsed.variableDeclarations) {
-      allVarDeclarations.push(`$${op.alias}_${varDecl.name}: ${varDecl.type}`);
-    }
-    let body = parsed.body;
-    const sortedDeclarations = [...parsed.variableDeclarations].sort(
-      (a, b) => b.name.length - a.name.length
-    );
-    for (const varDecl of sortedDeclarations) {
-      body = body.replaceAll(
-        new RegExp(`\\$${escapeRegex(varDecl.name)}\\b`, "g"),
-        `$${op.alias}_${varDecl.name}`
-      );
-    }
-    const aliasedBody = body.replace(/^\s*(\w+)/, `${op.alias}: $1`);
-    allSelections.push(aliasedBody);
-    for (const [key, value] of Object.entries(op.variables)) {
-      mergedVariables[`${op.alias}_${key}`] = value;
-    }
+// src/core/routing/engine/cli-detect.ts
+var CLI_ENV_CACHE_TTL_MS = 3e4;
+var cliEnvironmentCache = /* @__PURE__ */ new WeakMap();
+var cliEnvironmentInFlight = /* @__PURE__ */ new WeakMap();
+var defaultCliRunner = createSafeCliCommandRunner();
+async function detectCliEnvironment(runner) {
+  const version = await runner.run("gh", ["--version"], 1500).catch(() => null);
+  if (!version || version.exitCode !== 0) {
+    return { ghCliAvailable: false, ghAuthenticated: false };
   }
-  const fragmentBlock = allFragments.size > 0 ? "\n" + [...allFragments.values()].join("\n") : "";
-  const document = `mutation BatchComposite(${allVarDeclarations.join(", ")}) {
-${allSelections.join("\n")}
-}${fragmentBlock}`;
-  return { document, variables: mergedVariables };
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const auth = await runner.run("gh", ["auth", "status"], 2500).catch(() => null);
+  return { ghCliAvailable: true, ghAuthenticated: auth?.exitCode === 0 };
 }
-function parseOperation(document) {
-  const headerMatch = document.match(/(query|mutation)\s+\w+\s*\(([^)]*)\)/);
-  const variableDeclarations = [];
-  if (headerMatch && headerMatch[2]) {
-    const varString = headerMatch[2];
-    const varMatches = varString.matchAll(/\$(\w+)\s*:\s*([^,)]+)/g);
-    for (const match of varMatches) {
-      const name = match[1];
-      const type = match[2];
-      if (name && type) {
-        variableDeclarations.push({
-          name,
-          type: type.trim()
-        });
-      }
-    }
+async function detectCliEnvironmentCached(runner) {
+  const now = Date.now();
+  const cached = cliEnvironmentCache.get(runner);
+  if (cached && cached.expiresAt > now) {
+    return cached.value;
   }
-  const headerEnd = document.indexOf("{");
-  if (headerEnd === -1) {
-    throw new Error("Invalid mutation: no opening brace found");
+  const inFlight = cliEnvironmentInFlight.get(runner);
+  if (inFlight) {
+    return inFlight;
   }
-  let depth = 0;
-  let bodyStart = -1;
-  let bodyEnd = -1;
+  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;
+}
+
+// src/core/routing/engine/single.ts
+var DEFAULT_REASON = "DEFAULT_POLICY";
+async function runSingleTask(task, input, deps) {
+  const reason = deps.reason ?? DEFAULT_REASON;
+  const card = getOperationCard(task);
+  if (!card) {
+    logger.error("execute.unsupported_task", { task });
+    return normalizeError(
+      {
+        code: errorCodes.Validation,
+        message: `Unsupported task: ${task}`,
+        retryable: false
+      },
+      routePreferenceOrder[0],
+      { capabilityId: task, reason }
+    );
+  }
+  logger.debug("execute.start", { capability_id: task });
+  const startMs = Date.now();
+  const cliRunner = deps.cliRunner ?? defaultCliRunner;
+  const result = await execute({
+    card,
+    params: 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 () => {
+        return runGraphqlCapability(deps.githubClient, task, input);
+      },
+      cli: async () => {
+        return runCliCapability(cliRunner, task, input, card);
+      },
+      rest: async () => normalizeError(
+        {
+          code: errorCodes.AdapterUnsupported,
+          message: `Route 'rest' is not implemented for task '${task}'`,
+          retryable: false,
+          details: { route: "rest", task }
+        },
+        "rest",
+        { capabilityId: task, reason }
+      )
+    }
+  });
+  logger.info("execute.complete", {
+    capability_id: task,
+    ok: result.ok,
+    route_used: result.meta?.route_used ?? null,
+    duration_ms: Date.now() - startMs,
+    error_code: result.error?.code ?? null
+  });
+  return result;
+}
+
+// src/core/routing/engine/cli-dispatch.ts
+function startCliSteps(steps, requests, deps) {
+  return steps.filter((s) => s.route === "cli").map((step) => {
+    const req = requests[step.index];
+    if (req === void 0) {
+      return Promise.resolve([
+        step.index,
+        {
+          ok: false,
+          error: { code: errorCodes.Unknown, message: "missing request", retryable: false },
+          meta: { capability_id: step.card.capability_id, route_used: "cli" }
+        }
+      ]);
+    }
+    return runSingleTask(req.task, req.input, deps).then((result) => [step.index, result]).catch((err) => [
+      step.index,
+      {
+        ok: false,
+        error: {
+          code: errorCodes.Unknown,
+          message: err instanceof Error ? err.message : String(err),
+          retryable: false
+        },
+        meta: { capability_id: req.task, route_used: "cli" }
+      }
+    ]);
+  });
+}
+async function collectCliResults(cliPromises, cliSteps, requests) {
+  const cliResults = /* @__PURE__ */ new Map();
+  const outcomes = await Promise.allSettled(cliPromises);
+  for (let j = 0; j < cliSteps.length; j += 1) {
+    const step = cliSteps[j];
+    const outcome = outcomes[j];
+    if (step === void 0 || outcome === void 0) continue;
+    if (outcome.status === "fulfilled") {
+      const [resolvedIndex, result] = outcome.value;
+      cliResults.set(resolvedIndex, result);
+    } else {
+      const msg = outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason);
+      const req = requests[step.index];
+      cliResults.set(step.index, {
+        ok: false,
+        error: { code: errorCodes.Unknown, message: msg, retryable: false },
+        meta: { capability_id: req?.task ?? "unknown", route_used: "cli" }
+      });
+    }
+  }
+  return cliResults;
+}
+
+// src/gql/batch.ts
+function extractRootFieldName(query) {
+  const headerEnd = query.indexOf("{");
+  if (headerEnd === -1) return null;
+  const body = query.slice(headerEnd + 1);
+  const match = body.match(/^\s*(\w+)/);
+  return match?.[1] ?? null;
+}
+function buildBatchMutation(operations) {
+  if (operations.length === 0) {
+    throw new Error("buildBatchMutation requires at least one operation");
+  }
+  const allVarDeclarations = [];
+  const allSelections = [];
+  const mergedVariables = {};
+  const allFragments = /* @__PURE__ */ new Map();
+  for (const op of operations) {
+    const parsed = parseOperation(op.mutation);
+    for (const [name, text] of parsed.fragments) {
+      if (!allFragments.has(name)) {
+        allFragments.set(name, text);
+      }
+    }
+    for (const varDecl of parsed.variableDeclarations) {
+      allVarDeclarations.push(`$${op.alias}_${varDecl.name}: ${varDecl.type}`);
+    }
+    let body = parsed.body;
+    const sortedDeclarations = [...parsed.variableDeclarations].sort(
+      (a, b) => b.name.length - a.name.length
+    );
+    for (const varDecl of sortedDeclarations) {
+      body = body.replaceAll(
+        new RegExp(`\\$${escapeRegex(varDecl.name)}\\b`, "g"),
+        `$${op.alias}_${varDecl.name}`
+      );
+    }
+    const aliasedBody = body.replace(/^\s*(\w+)/, `${op.alias}: $1`);
+    allSelections.push(aliasedBody);
+    for (const [key, value] of Object.entries(op.variables)) {
+      mergedVariables[`${op.alias}_${key}`] = value;
+    }
+  }
+  const fragmentBlock = allFragments.size > 0 ? "\n" + [...allFragments.values()].join("\n") : "";
+  const document = `mutation BatchComposite(${allVarDeclarations.join(", ")}) {
+${allSelections.join("\n")}
+}${fragmentBlock}`;
+  return { document, variables: mergedVariables };
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseOperation(document) {
+  const headerMatch = document.match(/(query|mutation)\s+\w+\s*\(([^)]*)\)/);
+  const variableDeclarations = [];
+  if (headerMatch && headerMatch[2]) {
+    const varString = headerMatch[2];
+    const varMatches = varString.matchAll(/\$(\w+)\s*:\s*([^,)]+)/g);
+    for (const match of varMatches) {
+      const name = match[1];
+      const type = match[2];
+      if (name && type) {
+        variableDeclarations.push({
+          name,
+          type: type.trim()
+        });
+      }
+    }
+  }
+  const headerEnd = document.indexOf("{");
+  if (headerEnd === -1) {
+    throw new Error("Invalid mutation: no opening brace found");
+  }
+  let depth = 0;
+  let bodyStart = -1;
+  let bodyEnd = -1;
   for (let i = headerEnd; i < document.length; i++) {
     if (document[i] === "{") {
       if (depth === 0) bodyStart = i + 1;
@@ -4921,8 +5359,12 @@ function buildBatchQuery(operations) {
   const allVarDeclarations = [];
   const allSelections = [];
   const mergedVariables = {};
+  const allFragments = /* @__PURE__ */ new Map();
   for (const op of operations) {
     const parsed = parseOperation(op.query);
+    for (const [name, text] of parsed.fragments) {
+      if (!allFragments.has(name)) allFragments.set(name, text);
+    }
     for (const varDecl of parsed.variableDeclarations) {
       allVarDeclarations.push(`$${op.alias}_${varDecl.name}: ${varDecl.type}`);
     }
@@ -4943,9 +5385,10 @@ function buildBatchQuery(operations) {
     }
   }
   const varList = allVarDeclarations.length > 0 ? `(${allVarDeclarations.join(", ")})` : "";
+  const fragmentBlock = allFragments.size > 0 ? "\n" + [...allFragments.values()].join("\n") : "";
   const document = `query BatchChain${varList} {
 ${allSelections.join("\n")}
-}`;
+}${fragmentBlock}`;
   return { document, variables: mergedVariables };
 }
 
@@ -4993,26 +5436,6 @@ var IssueLabelsLookupDocument = `
 }
     `;
 
-// src/gql/operations/issue-labels-remove.generated.ts
-var IssueLabelsRemoveDocument = `
-    mutation IssueLabelsRemove($labelableId: ID!, $labelIds: [ID!]!) {
-  removeLabelsFromLabelable(
-    input: {labelableId: $labelableId, labelIds: $labelIds}
-  ) {
-    labelable {
-      ... on Issue {
-        id
-        labels(first: 50) {
-          nodes {
-            name
-          }
-        }
-      }
-    }
-  }
-}
-    `;
-
 // src/gql/operations/issue-milestone-lookup.generated.ts
 var IssueMilestoneLookupDocument = `
     query IssueMilestoneLookup($issueId: ID!, $milestoneNumber: Int!) {
@@ -5029,7 +5452,8 @@ var IssueMilestoneLookupDocument = `
     `;
 
 // src/gql/document-registry.ts
-var LOOKUP_DOCUMENTS = {
+var DOCUMENTS = {
+  // Resolution lookup queries (Phase 1)
   IssueAssigneesLookup: IssueAssigneesLookupDocument,
   IssueAssigneesLookupByNumber: IssueAssigneesLookupByNumberDocument,
   IssueCreateRepositoryId: IssueCreateRepositoryIdDocument,
@@ -5039,9 +5463,9 @@ var LOOKUP_DOCUMENTS = {
   IssueMilestoneLookupByNumber: IssueMilestoneLookupByNumberDocument,
   IssueNodeIdLookup: IssueNodeIdLookupDocument,
   IssueParentLookup: IssueParentLookupDocument,
-  PrNodeId: PrNodeIdDocument
-};
-var MUTATION_DOCUMENTS = {
+  PrNodeId: PrNodeIdDocument,
+  UserNodeId: UserNodeIdDocument,
+  // Mutation documents
   IssueAssigneesAdd: IssueAssigneesAddDocument,
   IssueAssigneesRemove: IssueAssigneesRemoveDocument,
   IssueAssigneesUpdate: IssueAssigneesUpdateDocument,
@@ -5059,24 +5483,51 @@ var MUTATION_DOCUMENTS = {
   IssueParentSet: IssueParentSetDocument,
   IssueReopen: IssueReopenDocument,
   IssueUpdate: IssueUpdateDocument,
+  PrAssigneesAdd: PrAssigneesAddDocument,
+  PrAssigneesRemove: PrAssigneesRemoveDocument,
+  PrBranchUpdate: PrBranchUpdateDocument,
   PrCommentReply: PrCommentReplyDocument,
   PrCommentResolve: PrCommentResolveDocument,
   PrCommentUnresolve: PrCommentUnresolveDocument,
-  PrReviewSubmit: PrReviewSubmitDocument
+  PrCreate: PrCreateDocument,
+  PrMerge: PrMergeDocument,
+  PrReviewSubmit: PrReviewSubmitDocument,
+  PrReviewsRequest: PrReviewsRequestDocument,
+  PrUpdate: PrUpdateDocument,
+  AddProjectV2Item: AddProjectV2ItemDocument,
+  RemoveProjectV2Item: RemoveProjectV2ItemDocument,
+  UpdateProjectV2ItemField: UpdateProjectV2ItemFieldDocument,
+  // Query documents
+  IssueView: IssueViewDocument,
+  IssueList: IssueListDocument,
+  IssueCommentsList: IssueCommentsListDocument,
+  IssueRelationsGet: IssueRelationsGetDocument,
+  IssueLinkedPrsList: IssueLinkedPrsListDocument,
+  PrView: PrViewDocument,
+  PrList: PrListDocument,
+  PrDiffListFiles: PrDiffListFilesDocument,
+  PrMergeStatus: PrMergeStatusDocument,
+  PrCommentsList: PrCommentsListDocument,
+  PrReviewsList: PrReviewsListDocument,
+  RepoView: RepoViewDocument,
+  RepoLabelsList: RepoLabelsListDocument,
+  RepoIssueTypesList: RepoIssueTypesListDocument,
+  ReleaseView: ReleaseViewDocument,
+  ReleaseList: ReleaseListDocument,
+  ProjectV2OrgView: ProjectV2OrgViewDocument,
+  ProjectV2UserView: ProjectV2UserViewDocument,
+  ProjectV2FieldsListOrg: ProjectV2FieldsListOrgDocument,
+  ProjectV2ItemsListOrg: ProjectV2ItemsListOrgDocument
 };
-function getLookupDocument(operationName) {
-  const doc = LOOKUP_DOCUMENTS[operationName];
+function getDocument(operationName) {
+  const doc = DOCUMENTS[operationName];
   if (!doc) {
-    throw new Error(`No lookup document registered for operation: ${operationName}`);
+    throw new Error(`No document registered for operation: ${operationName}`);
   }
   return doc;
 }
-function getMutationDocument(operationName) {
-  const doc = MUTATION_DOCUMENTS[operationName];
-  if (!doc) {
-    throw new Error(`No mutation document registered for operation: ${operationName}`);
-  }
-  return doc;
+function getLookupDocument(operationName) {
+  return getDocument(operationName);
 }
 
 // src/gql/resolve.ts
@@ -5150,8 +5601,8 @@ function applyInject(spec, lookupResult, input) {
   });
   return { [spec.target]: resolved };
 }
-function buildMutationVars(mutationDoc, input, resolved) {
-  const headerMatch = mutationDoc.match(/(?:query|mutation)\s+\w+\s*\(([^)]*)\)/);
+function buildOperationVars(operationDoc, input, resolved) {
+  const headerMatch = operationDoc.match(/(?:query|mutation)\s+\w+\s*\(([^)]*)\)/);
   const mutVarNames = /* @__PURE__ */ new Set();
   if (headerMatch?.[1]) {
     for (const match of headerMatch[1].matchAll(/\$(\w+)\s*:/g)) {
@@ -5172,211 +5623,131 @@ function buildMutationVars(mutationDoc, input, resolved) {
   return vars;
 }
 
-// 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
-      };
+// src/core/routing/engine/execute.ts
+async function runGqlExecutePhase(steps, requests, lookupResults, deps) {
+  const mutationInputs = [];
+  const queryInputs = [];
+  const stepErrors = /* @__PURE__ */ new Map();
+  const stepPreErrors = /* @__PURE__ */ new Map();
+  for (const step of steps) {
+    const { card, index, route } = step;
+    const req = requests[index];
+    if (req === void 0) continue;
+    try {
+      logger.debug("resolution.inject", { step: index, capability_id: req.task });
+      const resolved = {};
+      if (card.graphql?.resolution && lookupResults[index] !== void 0) {
+        for (const spec of card.graphql.resolution.inject) {
+          Object.assign(resolved, applyInject(spec, lookupResults[index], req.input));
+        }
+      }
+      if (!card.graphql) {
+        throw new Error(`Step ${index}: card has no graphql config for route '${route}'`);
+      }
+      const doc = getDocument(card.graphql.operationName);
+      const vars = buildOperationVars(doc, req.input, resolved);
+      if (route === "gql-mutation") {
+        mutationInputs.push({
+          alias: `step${index}`,
+          mutation: doc,
+          variables: vars,
+          stepIndex: index
+        });
+      } else {
+        queryInputs.push({
+          alias: `step${index}`,
+          query: doc,
+          variables: vars,
+          stepIndex: index
+        });
+      }
+    } catch (err) {
+      stepPreErrors.set(index, err instanceof Error ? err.message : String(err));
     }
-    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;
+  for (const [index, msg] of stepPreErrors) {
+    stepErrors.set(`step${index}`, msg);
   }
-  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;
-}
-function isRetryableCode(code) {
-  return code === errorCodes.RateLimit || code === errorCodes.Network || code === errorCodes.Server;
-}
-async function executeTask(request, deps) {
-  const reason = deps.reason ?? DEFAULT_REASON;
-  const card = getOperationCard(request.task);
-  if (!card) {
-    logger.error("execute.unsupported_task", { task: request.task });
-    return normalizeError(
-      {
-        code: errorCodes.Validation,
-        message: `Unsupported task: ${request.task}`,
-        retryable: false
-      },
-      routePreferenceOrder[0],
-      { capabilityId: request.task, reason }
-    );
-  }
-  logger.debug("execute.start", { capability_id: request.task });
-  const startMs = Date.now();
-  const cliRunner = deps.cliRunner ?? defaultCliRunner;
-  const result = await 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;
+  let mutationRawResult = {};
+  const mutationPromise = mutationInputs.length > 0 ? (async () => {
+    try {
+      const { document, variables } = buildBatchMutation(
+        mutationInputs.map(({ alias, mutation, variables: variables2 }) => ({
+          alias,
+          mutation,
+          variables: variables2
+        }))
+      );
+      logger.debug("mutation.batch_start", { count: mutationInputs.length });
+      const rawResponse = await deps.githubClient.queryRaw(
+        document,
+        variables
+      );
+      if (rawResponse.errors?.length) {
+        const attributedAliases = /* @__PURE__ */ new Set();
+        for (const err of rawResponse.errors) {
+          const alias = err.path?.[0];
+          if (typeof alias === "string" && alias.startsWith("step")) {
+            stepErrors.set(alias, err.message);
+            attributedAliases.add(alias);
+          }
         }
-        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;
+        if (attributedAliases.size === 0) {
+          for (const { alias } of mutationInputs) {
+            if (!stepErrors.has(alias)) {
+              stepErrors.set(alias, rawResponse.errors[0]?.message ?? "GraphQL batch error");
             }
           }
         }
       }
-      return preflightCheck(preflightInput);
-    },
-    routes: {
-      graphql: async () => {
-        return 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 }
-      )
-    }
-  });
-  logger.info("execute.complete", {
-    capability_id: request.task,
-    ok: result.ok,
-    route_used: result.meta?.route_used ?? null,
-    duration_ms: Date.now() - startMs,
-    error_code: result.error?.code ?? null
-  });
-  return result;
-}
-async function executeTasks(requests, deps) {
-  logger.debug("execute_batch.start", { count: requests.length });
-  const batchStart = Date.now();
-  if (requests.length === 1) {
-    const [req] = requests;
-    if (req === void 0) {
-      logger.info("execute_batch.complete", {
-        ok: false,
-        status: "failed",
-        total: 0,
-        succeeded: 0,
-        failed: 0,
-        duration_ms: Date.now() - batchStart
-      });
-      return {
-        status: "failed",
-        results: [],
-        meta: { route_used: "graphql", total: 0, succeeded: 0, failed: 0 }
-      };
-    }
-    const result = await executeTask({ task: req.task, input: req.input }, deps);
-    const step = result.ok ? { task: req.task, ok: true, data: result.data } : {
-      task: req.task,
-      ok: false,
-      error: result.error || {
-        code: errorCodes.Unknown,
-        message: "Unknown error",
-        retryable: false
+      mutationRawResult = rawResponse.data ?? {};
+      logger.debug("mutation.batch_complete", { count: mutationInputs.length });
+    } catch (err) {
+      const code = mapErrorToCode(err);
+      logger.error("mutation.batch_failed", { error_code: code });
+      for (const { alias } of mutationInputs) {
+        stepErrors.set(alias, err instanceof Error ? err.message : String(err));
       }
-    };
-    const succeeded1 = result.ok ? 1 : 0;
-    logger.info("execute_batch.complete", {
-      ok: result.ok,
-      status: result.ok ? "success" : "failed",
-      total: 1,
-      succeeded: succeeded1,
-      failed: 1 - succeeded1,
-      duration_ms: Date.now() - batchStart
-    });
-    return {
-      status: result.ok ? "success" : "failed",
-      results: [step],
-      meta: {
-        route_used: result.meta?.route_used ?? "graphql",
-        total: 1,
-        succeeded: succeeded1,
-        failed: 1 - succeeded1
+    }
+  })() : Promise.resolve();
+  let queryRawResult = {};
+  const queryPromise = queryInputs.length > 0 ? (async () => {
+    try {
+      const { document, variables } = buildBatchQuery(
+        queryInputs.map(({ alias, query, variables: variables2 }) => ({
+          alias,
+          query,
+          variables: variables2
+        }))
+      );
+      logger.debug("query.batch_start", { count: queryInputs.length });
+      const rawResult = await deps.githubClient.query(
+        document,
+        variables
+      );
+      queryRawResult = rawResult;
+      logger.debug("query.batch_complete", { count: queryInputs.length });
+    } catch (err) {
+      const code = mapErrorToCode(err);
+      logger.error("query.batch_failed", { error_code: code });
+      for (const { alias } of queryInputs) {
+        stepErrors.set(alias, err instanceof Error ? err.message : String(err));
       }
-    };
-  }
+    }
+  })() : Promise.resolve();
+  await Promise.allSettled([mutationPromise, queryPromise]);
+  return {
+    mutationRawResult,
+    queryRawResult,
+    stepErrors
+  };
+}
+
+// src/core/routing/engine/preflight.ts
+function runPreflight(requests) {
   const preflightErrorByIndex = /* @__PURE__ */ new Map();
   const cards = [];
+  const cardIsCliOnly = [];
   for (let i = 0; i < requests.length; i += 1) {
     const req = requests[i];
     if (req === void 0) continue;
@@ -5390,10 +5761,12 @@ async function executeTasks(requests, deps) {
         const details = inputValidation.errors.map((e) => `${e.instancePath || "root"}: ${e.message}`).join("; ");
         throw new Error(`Input validation failed: ${details}`);
       }
-      if (!card.graphql) {
-        throw new Error(`capability '${req.task}' has no GraphQL route and cannot be chained`);
+      if (!card.graphql && !card.cli) {
+        throw new Error(
+          `capability '${req.task}' has no supported route (graphql or cli) and cannot be chained`
+        );
       }
-      if (card.graphql.resolution) {
+      if (card.graphql?.resolution) {
         const { lookup } = card.graphql.resolution;
         for (const [, inputField] of Object.entries(lookup.vars)) {
           if (req.input[inputField] === void 0) {
@@ -5404,6 +5777,7 @@ async function executeTasks(requests, deps) {
         }
       }
       cards.push(card);
+      cardIsCliOnly.push(!card.graphql);
     } catch (err) {
       preflightErrorByIndex.set(i, {
         task: req.task,
@@ -5417,51 +5791,67 @@ async function executeTasks(requests, deps) {
     }
   }
   if (preflightErrorByIndex.size > 0) {
-    return {
-      status: "failed",
-      results: requests.map(
-        (req, i) => preflightErrorByIndex.get(i) ?? {
-          task: req.task,
-          ok: false,
-          error: {
-            code: errorCodes.Unknown,
-            message: "pre-flight failed",
-            retryable: false
-          }
+    const results = requests.map(
+      (req, i) => preflightErrorByIndex.get(i) ?? {
+        task: req?.task ?? "unknown",
+        ok: false,
+        error: {
+          code: errorCodes.Unknown,
+          message: "pre-flight failed",
+          retryable: false
         }
-      ),
-      meta: {
-        route_used: "graphql",
-        total: requests.length,
-        succeeded: 0,
-        failed: requests.length
       }
-    };
-  }
-  const lookupInputs = [];
-  const lookupResults = {};
-  function buildLookupVars(card, req) {
-    const vars = {};
-    if (card.graphql?.resolution) {
-      for (const [lookupVar, inputField] of Object.entries(card.graphql.resolution.lookup.vars)) {
-        vars[lookupVar] = req.input[inputField];
-      }
-    }
-    return vars;
+    );
+    const anyGqlCard = cardIsCliOnly.some((isCliOnly) => !isCliOnly);
+    const routeUsed = !anyGqlCard && cards.length > 0 ? "cli" : "graphql";
+    return { ok: false, results, routeUsed };
   }
+  const steps = [];
+  let cardIndex = 0;
   for (let i = 0; i < requests.length; i += 1) {
-    const card = cards[i];
     const req = requests[i];
-    if (card === void 0 || req === void 0) continue;
+    const card = cards[cardIndex];
+    if (req === void 0 || card === void 0) continue;
+    cardIndex += 1;
+    let route;
+    if (!card.graphql) {
+      route = "cli";
+    } else if (card.graphql.operationType === "query") {
+      route = "gql-query";
+    } else {
+      route = "gql-mutation";
+    }
+    steps.push({ route, card, index: i, request: req });
+  }
+  return { ok: true, steps, cards };
+}
+
+// src/core/routing/engine/resolve.ts
+function buildLookupVars(card, input) {
+  const vars = {};
+  if (card.graphql?.resolution) {
+    for (const [lookupVar, inputField] of Object.entries(card.graphql.resolution.lookup.vars)) {
+      vars[lookupVar] = input[inputField];
+    }
+  }
+  return vars;
+}
+async function runResolutionPhase(steps, requests, githubClient, resolutionCache) {
+  const lookupResults = {};
+  const lookupInputs = [];
+  for (const step of steps) {
+    const { card, index } = step;
     if (!card.graphql?.resolution) continue;
-    const lookupVars = buildLookupVars(card, req);
-    if (deps.resolutionCache) {
+    const req = requests[index];
+    if (req === void 0) continue;
+    const lookupVars = buildLookupVars(card, req.input);
+    if (resolutionCache) {
       const cacheKey = buildCacheKey(card.graphql.resolution.lookup.operationName, lookupVars);
-      const cached = deps.resolutionCache.get(cacheKey);
+      const cached = resolutionCache.get(cacheKey);
       if (cached !== void 0) {
-        lookupResults[i] = cached;
+        lookupResults[index] = cached;
         logger.debug("resolution.cache_hit", {
-          step: i,
+          step: index,
           operation: card.graphql.resolution.lookup.operationName,
           key: cacheKey
         });
@@ -5469,237 +5859,176 @@ async function executeTasks(requests, deps) {
       }
     }
     logger.debug("resolution.lookup_scheduled", {
-      step: i,
+      step: index,
       operation: card.graphql.resolution.lookup.operationName
     });
     lookupInputs.push({
-      alias: `step${i}`,
+      alias: `step${index}`,
       query: getLookupDocument(card.graphql.resolution.lookup.operationName),
       variables: lookupVars,
-      stepIndex: i
+      stepIndex: index
     });
   }
-  if (lookupInputs.length > 0) {
-    try {
-      const { document, variables } = buildBatchQuery(
-        lookupInputs.map(({ alias, query, variables: variables2 }) => ({
-          alias,
-          query,
-          variables: variables2
-        }))
-      );
-      logger.debug("query.batch_start", { count: lookupInputs.length });
-      const rawResult = await deps.githubClient.query(document, variables);
-      logger.debug("query.batch_complete", { count: lookupInputs.length });
-      for (const { alias, query, stepIndex } of lookupInputs) {
-        const rawValue = rawResult[alias];
-        const rootFieldName = extractRootFieldName(query);
-        const result = rootFieldName !== null ? { [rootFieldName]: rawValue } : rawValue;
-        lookupResults[stepIndex] = result;
-        logger.debug("resolution.step_resolved", { step: stepIndex, alias });
-        if (deps.resolutionCache && result !== void 0) {
-          const card = cards[stepIndex];
-          const req = requests[stepIndex];
-          if (card?.graphql?.resolution && req) {
-            const lookupVars = buildLookupVars(card, req);
-            deps.resolutionCache.set(
-              buildCacheKey(card.graphql.resolution.lookup.operationName, lookupVars),
-              result
-            );
-            logger.debug("resolution.cache_set", {
-              step: stepIndex,
-              operation: card.graphql.resolution.lookup.operationName
-            });
-          }
-        }
-      }
-    } catch (err) {
-      const errorMsg = err instanceof Error ? err.message : String(err);
-      const code = mapErrorToCode(err);
-      logger.error("resolution.lookup_failed", {
-        count: lookupInputs.length,
-        error_code: code,
-        message: errorMsg
-      });
-      return {
-        status: "failed",
-        results: requests.map((req) => ({
-          task: req.task,
-          ok: false,
-          error: {
-            code,
-            message: `Phase 1 (resolution) failed: ${errorMsg}`,
-            retryable: isRetryableCode(code)
-          }
-        })),
-        meta: {
-          route_used: "graphql",
-          total: requests.length,
-          succeeded: 0,
-          failed: requests.length
-        }
-      };
-    }
+  if (lookupInputs.length === 0) {
+    return lookupResults;
   }
-  const mutationInputs = [];
-  const stepPreResults = {};
-  for (let i = 0; i < requests.length; i += 1) {
-    const card = cards[i];
-    const req = requests[i];
-    if (card === void 0 || req === void 0) continue;
-    try {
-      logger.debug("resolution.inject", { step: i, capability_id: req.task });
-      const resolved = {};
-      if (card.graphql?.resolution && lookupResults[i] !== void 0) {
-        for (const spec of card.graphql.resolution.inject) {
-          Object.assign(resolved, applyInject(spec, lookupResults[i], req.input));
-        }
-      }
-      if (card.graphql === void 0) {
-        throw new Error("card.graphql is unexpectedly undefined");
+  const { document, variables } = buildBatchQuery(
+    lookupInputs.map(({ alias, query, variables: variables2 }) => ({
+      alias,
+      query,
+      variables: variables2
+    }))
+  );
+  logger.debug("query.batch_start", { count: lookupInputs.length });
+  const rawResult = await githubClient.query(document, variables);
+  logger.debug("query.batch_complete", { count: lookupInputs.length });
+  for (const { alias, query, stepIndex } of lookupInputs) {
+    const rawValue = rawResult[alias];
+    if (rawValue === void 0) {
+      logger.debug("resolution.step_missing", { step: stepIndex, alias });
+      continue;
+    }
+    const rootFieldName = extractRootFieldName(query);
+    const result = rootFieldName !== null ? { [rootFieldName]: rawValue } : rawValue;
+    lookupResults[stepIndex] = result;
+    logger.debug("resolution.step_resolved", { step: stepIndex, alias });
+    if (resolutionCache) {
+      const step = steps.find((s) => s.index === stepIndex);
+      const req = requests[stepIndex];
+      if (step?.card.graphql?.resolution && req) {
+        const lookupVars = buildLookupVars(step.card, req.input);
+        resolutionCache.set(
+          buildCacheKey(step.card.graphql.resolution.lookup.operationName, lookupVars),
+          result
+        );
+        logger.debug("resolution.cache_set", {
+          step: stepIndex,
+          operation: step.card.graphql.resolution.lookup.operationName
+        });
       }
-      const mutDoc = getMutationDocument(card.graphql.operationName);
-      const mutVars = buildMutationVars(mutDoc, req.input, resolved);
-      mutationInputs.push({
-        alias: `step${i}`,
-        mutation: mutDoc,
-        variables: mutVars,
-        stepIndex: i
-      });
-    } catch (err) {
-      stepPreResults[i] = {
-        task: req.task,
-        ok: false,
-        error: {
-          code: mapErrorToCode(err),
-          message: err instanceof Error ? err.message : String(err),
-          retryable: false
-        }
-      };
     }
   }
-  let rawMutResult = {};
-  const stepErrors = /* @__PURE__ */ new Map();
-  if (mutationInputs.length > 0) {
-    try {
-      const { document, variables } = buildBatchMutation(
-        mutationInputs.map(({ alias, mutation, variables: variables2 }) => ({
-          alias,
-          mutation,
-          variables: variables2
-        }))
-      );
-      logger.debug("mutation.batch_start", { count: mutationInputs.length });
-      const rawResponse = await deps.githubClient.queryRaw(
-        document,
-        variables
-      );
-      if (rawResponse.errors?.length) {
-        for (const err of rawResponse.errors) {
-          const alias = err.path?.[0];
-          if (typeof alias === "string" && alias.startsWith("step")) {
-            stepErrors.set(alias, err.message);
-          }
-        }
-        if (stepErrors.size === 0) {
-          for (const { alias } of mutationInputs) {
-            stepErrors.set(alias, rawResponse.errors[0]?.message ?? "GraphQL batch error");
-          }
-        }
-      }
-      rawMutResult = rawResponse.data ?? {};
-      logger.debug("mutation.batch_complete", { count: mutationInputs.length });
-    } catch (err) {
-      const code = mapErrorToCode(err);
-      logger.error("mutation.batch_failed", { error_code: code });
-      for (const { stepIndex } of mutationInputs) {
-        const reqAtIndex = requests[stepIndex];
-        if (reqAtIndex !== void 0) {
-          stepPreResults[stepIndex] = {
-            task: reqAtIndex.task,
-            ok: false,
-            error: {
-              code,
-              message: err instanceof Error ? err.message : String(err),
-              retryable: isRetryableCode(code)
-            }
-          };
-        }
+  return lookupResults;
+}
+
+// src/core/routing/engine/batch.ts
+async function executeBatch(requests, deps) {
+  const batchStartMs = Date.now();
+  const preflight = runPreflight(requests);
+  if (!preflight.ok) {
+    return {
+      status: "failed",
+      results: preflight.results,
+      meta: {
+        route_used: preflight.routeUsed,
+        total: requests.length,
+        succeeded: 0,
+        failed: requests.length
       }
-    }
+    };
   }
-  const results = requests.map((req, stepIndex) => {
-    const preResult = stepPreResults[stepIndex];
-    if (preResult !== void 0) return preResult;
-    const mutInput = mutationInputs.find((m) => m.stepIndex === stepIndex);
-    if (mutInput === void 0) {
-      return {
-        task: req.task,
-        ok: false,
-        error: {
-          code: errorCodes.Unknown,
-          message: "step skipped",
-          retryable: false
-        }
-      };
-    }
-    const stepError = stepErrors.get(mutInput.alias);
-    if (stepError !== void 0) {
-      return {
-        task: req.task,
-        ok: false,
-        error: {
-          code: mapErrorToCode(stepError),
-          message: stepError,
-          retryable: false
-        }
-      };
-    }
-    if (rawMutResult == null || typeof rawMutResult !== "object") {
-      return {
-        task: req.task,
-        ok: false,
-        error: {
-          code: errorCodes.Unknown,
-          message: `unexpected mutation response shape for alias ${mutInput.alias}`,
-          retryable: false
-        }
-      };
-    }
-    if (!(mutInput.alias in rawMutResult)) {
+  const { steps } = preflight;
+  const cliSteps = steps.filter((s) => s.route === "cli");
+  const gqlSteps = steps.filter((s) => s.route === "gql-query" || s.route === "gql-mutation");
+  const cliStepCount = cliSteps.length;
+  const cliPromises = startCliSteps(steps, requests, deps);
+  let lookupResults = {};
+  try {
+    lookupResults = await runResolutionPhase(
+      gqlSteps,
+      requests,
+      deps.githubClient,
+      deps.resolutionCache
+    );
+  } catch (err) {
+    const code = mapErrorToCode(err);
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    logger.error("resolution.lookup_failed", {
+      count: gqlSteps.length,
+      error_code: code,
+      message: errorMsg
+    });
+    const cliResults2 = await collectCliResults(cliPromises, cliSteps, requests);
+    return assembleResolutionFailure(
+      requests,
+      steps,
+      {
+        code,
+        message: `Phase 1 (resolution) failed: ${errorMsg}`,
+        retryable: isRetryableCode(code)
+      },
+      cliResults2
+    );
+  }
+  const { mutationRawResult, queryRawResult, stepErrors } = await runGqlExecutePhase(
+    gqlSteps,
+    requests,
+    lookupResults,
+    deps
+  );
+  const cliResults = await collectCliResults(cliPromises, cliSteps, requests);
+  return assembleChainResult({
+    steps,
+    requests,
+    mutationRawResult,
+    queryRawResult,
+    stepErrors,
+    cliResults,
+    cliStepCount,
+    batchStartMs
+  });
+}
+
+// src/core/routing/engine/index.ts
+async function executeTask(request, deps) {
+  return runSingleTask(request.task, request.input, deps);
+}
+async function executeTasks(requests, deps) {
+  logger.debug("execute_batch.start", { count: requests.length });
+  if (requests.length === 0) {
+    return {
+      status: "failed",
+      results: [],
+      meta: { route_used: "graphql", total: 0, succeeded: 0, failed: 0 }
+    };
+  }
+  if (requests.length === 1) {
+    const req = requests[0];
+    if (req === void 0) {
       return {
-        task: req.task,
-        ok: false,
-        error: {
-          code: errorCodes.Unknown,
-          message: `missing mutation result for alias ${mutInput.alias}`,
-          retryable: false
-        }
+        status: "failed",
+        results: [],
+        meta: { route_used: "graphql", total: 0, succeeded: 0, failed: 0 }
       };
     }
-    const data = rawMutResult[mutInput.alias];
-    return { task: req.task, ok: true, data };
-  });
-  const succeeded = results.filter((r) => r.ok).length;
-  const status = succeeded === results.length ? "success" : succeeded === 0 ? "failed" : "partial";
-  logger.info("execute_batch.complete", {
-    ok: status !== "failed",
-    status,
-    total: results.length,
-    succeeded,
-    failed: results.length - succeeded,
-    duration_ms: Date.now() - batchStart
-  });
-  return {
-    status,
-    results,
-    meta: {
-      route_used: "graphql",
-      total: results.length,
+    const batchStartMs = Date.now();
+    const result = await runSingleTask(req.task, req.input, deps);
+    const step = result.ok ? { task: req.task, ok: true, data: result.data } : {
+      task: req.task,
+      ok: false,
+      error: result.error ?? {
+        code: errorCodes.Unknown,
+        message: "Unknown error",
+        retryable: false
+      }
+    };
+    const succeeded = result.ok ? 1 : 0;
+    const routeUsed = result.meta?.route_used ?? "graphql";
+    logger.info("execute_batch.complete", {
+      ok: result.ok,
+      status: result.ok ? "success" : "failed",
+      total: 1,
       succeeded,
-      failed: results.length - succeeded
-    }
-  };
+      failed: 1 - succeeded,
+      duration_ms: Date.now() - batchStartMs
+    });
+    return {
+      status: result.ok ? "success" : "failed",
+      results: [step],
+      meta: { route_used: routeUsed, total: 1, succeeded, failed: 1 - succeeded }
+    };
+  }
+  return executeBatch(requests, deps);
 }
 
 // src/gql/github-client.ts
@@ -5718,11 +6047,15 @@ function createGithubClient(transport) {
   let issueMutations;
   let prQueries;
   let prMutations;
-  const loadRepo = async () => repo ??= await import("./repo-JDUHFPZF.js");
-  const loadIssueQueries = async () => issueQueries ??= await import("./issue-queries-GRA4MKPD.js");
-  const loadIssueMutations = async () => issueMutations ??= await import("./issue-mutations-FJNZW7L5.js");
-  const loadPrQueries = async () => prQueries ??= await import("./pr-queries-UOEOXIJQ.js");
-  const loadPrMutations = async () => prMutations ??= await import("./pr-mutations-UG67YOF5.js");
+  let release;
+  let project;
+  const loadRepo = async () => repo ??= await import("./repo-M6DKCWBG.js");
+  const loadIssueQueries = async () => issueQueries ??= await import("./issue-queries-ORG3VPK4.js");
+  const loadIssueMutations = async () => issueMutations ??= await import("./issue-mutations-OW464JP3.js");
+  const loadPrQueries = async () => prQueries ??= await import("./pr-queries-6CJJW7BT.js");
+  const loadPrMutations = async () => prMutations ??= await import("./pr-mutations-WOTG6FAB.js");
+  const loadRelease = async () => release ??= await import("./release-33236BBA.js");
+  const loadProject = async () => project ??= await import("./project-QFSCYDDW.js");
   return {
     query: (query, variables) => graphqlClient.query(query, variables),
     queryRaw: (query, variables) => graphqlClient.queryRaw(query, variables),
@@ -5737,10 +6070,12 @@ function createGithubClient(transport) {
     deleteIssue: async (input) => (await loadIssueMutations()).runIssueDelete(transport, input),
     updateIssueLabels: async (input) => (await loadIssueMutations()).runIssueLabelsUpdate(transport, input),
     addIssueLabels: async (input) => (await loadIssueMutations()).runIssueLabelsAdd(transport, input),
+    removeIssueLabels: async (input) => (await loadIssueMutations()).runIssueLabelsRemove(transport, input),
     updateIssueAssignees: async (input) => (await loadIssueMutations()).runIssueAssigneesUpdate(transport, input),
     addIssueAssignees: async (input) => (await loadIssueMutations()).runIssueAssigneesAdd(transport, input),
     removeIssueAssignees: async (input) => (await loadIssueMutations()).runIssueAssigneesRemove(transport, input),
     setIssueMilestone: async (input) => (await loadIssueMutations()).runIssueMilestoneSet(transport, input),
+    clearIssueMilestone: async (input) => (await loadIssueMutations()).runIssueMilestoneClear(transport, input),
     createIssueComment: async (input) => (await loadIssueMutations()).runIssueCommentCreate(transport, input),
     fetchIssueLinkedPrs: async (input) => (await loadIssueMutations()).runIssueLinkedPrsList(transport, input),
     fetchIssueRelations: async (input) => (await loadIssueMutations()).runIssueRelationsGet(transport, input),
@@ -5757,7 +6092,25 @@ function createGithubClient(transport) {
     replyToReviewThread: async (input) => (await loadPrMutations()).runReplyToReviewThread(transport, input),
     resolveReviewThread: async (input) => (await loadPrMutations()).runResolveReviewThread(transport, input),
     unresolveReviewThread: async (input) => (await loadPrMutations()).runUnresolveReviewThread(transport, input),
-    submitPrReview: async (input) => (await loadPrMutations()).runSubmitPrReview(transport, input)
+    submitPrReview: async (input) => (await loadPrMutations()).runSubmitPrReview(transport, input),
+    fetchRepoLabelsList: async (input) => (await loadRepo()).runRepoLabelsList(transport, input),
+    fetchRepoIssueTypesList: async (input) => (await loadRepo()).runRepoIssueTypesList(transport, input),
+    fetchReleaseView: async (input) => (await loadRelease()).runReleaseView(transport, input),
+    fetchReleaseList: async (input) => (await loadRelease()).runReleaseList(transport, input),
+    fetchProjectV2OrgView: async (input) => (await loadProject()).runProjectV2OrgView(transport, input),
+    fetchProjectV2UserView: async (input) => (await loadProject()).runProjectV2UserView(transport, input),
+    fetchProjectV2FieldsList: async (input) => (await loadProject()).runProjectV2FieldsList(transport, input),
+    fetchProjectV2ItemsList: async (input) => (await loadProject()).runProjectV2ItemsList(transport, input),
+    createPr: async (input) => (await loadPrMutations()).runPrCreate(transport, input),
+    updatePr: async (input) => (await loadPrMutations()).runPrUpdate(transport, input),
+    mergePr: async (input) => (await loadPrMutations()).runPrMerge(transport, input),
+    updatePrBranch: async (input) => (await loadPrMutations()).runPrBranchUpdate(transport, input),
+    addPrAssignees: async (input) => (await loadPrMutations()).runPrAssigneesAdd(transport, input),
+    removePrAssignees: async (input) => (await loadPrMutations()).runPrAssigneesRemove(transport, input),
+    requestPrReviews: async (input) => (await loadPrMutations()).runPrReviewsRequest(transport, input),
+    addProjectV2Item: async (input) => (await loadProject()).runProjectV2ItemAdd(transport, input),
+    removeProjectV2Item: async (input) => (await loadProject()).runProjectV2ItemRemove(transport, input),
+    updateProjectV2ItemField: async (input) => (await loadProject()).runProjectV2ItemFieldUpdate(transport, input)
   };
 }
 
@@ -5776,4 +6129,4 @@ export {
   createGithubClientFromToken,
   createGithubClient
 };
-//# sourceMappingURL=chunk-3P3KHWFU.js.map
+//# sourceMappingURL=chunk-M5PJLKL5.js.map