agent-relay 6.0.10 → 6.0.12

package/dist/index.cjs

@@ -5411,8 +5411,8 @@ var require_ignore = __commonJS({
       (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
       pattern
     );
-    var isString = (subject) => typeof subject === "string";
-    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var isString2 = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString2(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
     var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
     var IgnoreRule = class {
       constructor(pattern, mark, body, ignoreCase, negative, prefix) {
@@ -5479,7 +5479,7 @@ var require_ignore = __commonJS({
           this._added = true;
           return;
         }
-        if (isString(pattern)) {
+        if (isString2(pattern)) {
           pattern = {
             pattern
           };
@@ -5494,7 +5494,7 @@ var require_ignore = __commonJS({
       add(pattern) {
         this._added = false;
         makeArray(
-          isString(pattern) ? splitPattern(pattern) : pattern
+          isString2(pattern) ? splitPattern(pattern) : pattern
         ).forEach(this._add, this);
         return this._added;
       }
@@ -5536,7 +5536,7 @@ var require_ignore = __commonJS({
       throw new Ctor(message);
     };
     var checkPath = (path25, originalPath, doThrow) => {
-      if (!isString(path25)) {
+      if (!isString2(path25)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
@@ -18730,6 +18730,1794 @@ var init_listr_renderer = __esm({
   }
 });
 
+// packages/github-primitive/src/constants.ts
+var DEFAULT_TIMEOUT, DEFAULT_MAX_RETRIES, DEFAULT_GH_PATH, DEFAULT_NANGO_BASE_URL, DEFAULT_NANGO_PROVIDER_CONFIG_KEY, DEFAULT_RELAY_CLOUD_GITHUB_PROXY_ENDPOINT, DEFAULT_USER_AGENT;
+var init_constants = __esm({
+  "packages/github-primitive/src/constants.ts"() {
+    "use strict";
+    DEFAULT_TIMEOUT = 3e4;
+    DEFAULT_MAX_RETRIES = 3;
+    DEFAULT_GH_PATH = "gh";
+    DEFAULT_NANGO_BASE_URL = "https://api.nango.dev";
+    DEFAULT_NANGO_PROVIDER_CONFIG_KEY = "github";
+    DEFAULT_RELAY_CLOUD_GITHUB_PROXY_ENDPOINT = "/api/integrations/github/proxy";
+    DEFAULT_USER_AGENT = "agent-relay-github-primitive";
+  }
+});
+
+// packages/github-primitive/src/types.ts
+var GitHubAction, GITHUB_ACTIONS, GitHubApiError, GitHubClientInterface;
+var init_types = __esm({
+  "packages/github-primitive/src/types.ts"() {
+    "use strict";
+    GitHubAction = /* @__PURE__ */ ((GitHubAction2) => {
+      GitHubAction2["ListRepos"] = "listRepos";
+      GitHubAction2["GetRepo"] = "getRepo";
+      GitHubAction2["ListIssues"] = "listIssues";
+      GitHubAction2["CreateIssue"] = "createIssue";
+      GitHubAction2["UpdateIssue"] = "updateIssue";
+      GitHubAction2["CloseIssue"] = "closeIssue";
+      GitHubAction2["ListPRs"] = "listPRs";
+      GitHubAction2["GetPR"] = "getPR";
+      GitHubAction2["CreatePR"] = "createPR";
+      GitHubAction2["UpdatePR"] = "updatePR";
+      GitHubAction2["MergePR"] = "mergePR";
+      GitHubAction2["ListFiles"] = "listFiles";
+      GitHubAction2["ReadFile"] = "readFile";
+      GitHubAction2["CreateFile"] = "createFile";
+      GitHubAction2["UpdateFile"] = "updateFile";
+      GitHubAction2["DeleteFile"] = "deleteFile";
+      GitHubAction2["CreateBranch"] = "createBranch";
+      GitHubAction2["ListBranches"] = "listBranches";
+      GitHubAction2["ListCommits"] = "listCommits";
+      GitHubAction2["CreateCommit"] = "createCommit";
+      GitHubAction2["GetUser"] = "getUser";
+      GitHubAction2["ListOrganizations"] = "listOrganizations";
+      return GitHubAction2;
+    })(GitHubAction || {});
+    GITHUB_ACTIONS = Object.values(GitHubAction);
+    GitHubApiError = class extends Error {
+      status;
+      responseBody;
+      responseHeaders;
+      cause;
+      constructor(message, options = {}) {
+        super(message);
+        this.name = "GitHubApiError";
+        this.status = options.status;
+        this.responseBody = options.responseBody;
+        this.responseHeaders = options.responseHeaders;
+        this.cause = options.cause;
+      }
+    };
+    GitHubClientInterface = class {
+      config;
+      constructor(config2) {
+        this.config = config2;
+      }
+      getRuntimeConfig() {
+        return this.config;
+      }
+    };
+  }
+});
+
+// packages/github-primitive/src/actions/utils.ts
+async function withActionError(description, operation) {
+  try {
+    return await operation();
+  } catch (error51) {
+    if (error51 instanceof GitHubApiError) {
+      throw new GitHubApiError(`Failed to ${description}: ${error51.message}`, {
+        status: error51.status,
+        responseBody: error51.responseBody,
+        responseHeaders: error51.responseHeaders,
+        cause: error51
+      });
+    }
+    throw new GitHubApiError(`Failed to ${description}: ${errorMessage(error51)}`, { cause: error51 });
+  }
+}
+function assertOwnerRepo(owner, repo) {
+  assertNonEmptyString(owner, "owner");
+  assertNonEmptyString(repo, "repo");
+}
+function assertNonEmptyString(value, name) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new GitHubApiError(`GitHub ${name} must be a non-empty string.`);
+  }
+  return value.trim();
+}
+function assertPositiveInteger(value, name) {
+  if (!Number.isInteger(value) || value < 1) {
+    throw new GitHubApiError(`GitHub ${name} must be a positive integer.`);
+  }
+  return value;
+}
+function repoEndpoint(owner, repo, suffix = "") {
+  assertOwnerRepo(owner, repo);
+  return `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}${suffix}`;
+}
+function contentsEndpoint(owner, repo, path25 = "") {
+  const normalizedPath = normalizeRepoPath(path25);
+  const suffix = normalizedPath ? `/contents/${encodeRepoPath(normalizedPath)}` : "/contents";
+  return repoEndpoint(owner, repo, suffix);
+}
+function branchEndpoint(owner, repo, branch) {
+  const normalizedBranch = assertNonEmptyString(branch, "branch");
+  return repoEndpoint(owner, repo, `/branches/${encodeURIComponent(normalizedBranch)}`);
+}
+function normalizeRepoPath(path25) {
+  return path25?.trim().replace(/^\/+/, "").replace(/\/+$/, "") ?? "";
+}
+function normalizePerPage(perPage) {
+  if (typeof perPage === "undefined") {
+    return void 0;
+  }
+  if (!Number.isInteger(perPage) || perPage < 1) {
+    throw new GitHubApiError("GitHub perPage must be a positive integer.");
+  }
+  return Math.min(perPage, 100);
+}
+function removeUndefinedValues(values) {
+  const result = {};
+  for (const [key, value] of Object.entries(values)) {
+    if (typeof value !== "undefined") {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function hasDefinedValue(values) {
+  return Object.values(values).some((value) => typeof value !== "undefined");
+}
+function optionalRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function appendQuery(path25, query) {
+  if (!query) {
+    return path25;
+  }
+  const params = new URLSearchParams();
+  for (const [name, rawValue] of Object.entries(query)) {
+    const values = Array.isArray(rawValue) ? rawValue : [rawValue];
+    for (const value of values) {
+      if (value !== null && typeof value !== "undefined") {
+        params.append(name, String(value));
+      }
+    }
+  }
+  const serialized = params.toString();
+  if (!serialized) {
+    return path25;
+  }
+  return `${path25}${path25.includes("?") ? "&" : "?"}${serialized}`;
+}
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function trimTrailingSlash(value) {
+  const trimmed = nonEmpty(value);
+  return trimmed?.replace(/\/+$/, "");
+}
+function queryWithPerPage(query, perPage) {
+  const normalizedPerPage = normalizePerPage(perPage);
+  return typeof normalizedPerPage === "undefined" ? query : {
+    ...query,
+    per_page: normalizedPerPage
+  };
+}
+function asRecord(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new GitHubApiError(`GitHub API response for ${name} was not an object.`);
+  }
+  return value;
+}
+function asArray(value, name) {
+  if (!Array.isArray(value)) {
+    throw new GitHubApiError(`GitHub API response for ${name} was not an array.`);
+  }
+  return value;
+}
+function mapGitHubOwner(value) {
+  const owner = asRecord(value, "owner");
+  return {
+    login: stringValue(owner.login),
+    type: stringValue(owner.type, "User"),
+    id: numberValue(owner.id),
+    avatarUrl: optionalString(owner.avatar_url),
+    htmlUrl: optionalString(owner.html_url)
+  };
+}
+function mapLogin(value) {
+  const record2 = asRecord(value, "user");
+  return {
+    login: stringValue(record2.login)
+  };
+}
+function mapLogins(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map(mapLogin);
+}
+function stringValue(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberValue(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function booleanValue(value, fallback = false) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function stateValue(value) {
+  return value === "closed" ? "closed" : "open";
+}
+function visibilityValue(value, isPrivate) {
+  if (value === "public" || value === "private" || value === "internal") {
+    return value;
+  }
+  return isPrivate ? "private" : "public";
+}
+function errorMessage(error51) {
+  return error51 instanceof Error ? error51.message : String(error51);
+}
+function encodeRepoPath(path25) {
+  return path25.split("/").map(encodeURIComponent).join("/");
+}
+var init_utils = __esm({
+  "packages/github-primitive/src/actions/utils.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// packages/github-primitive/src/actions/branches.ts
+async function listBranches(adapter, owner, repo) {
+  return withActionError(`list GitHub branches for ${owner}/${repo}`, async () => {
+    assertOwnerRepo(owner, repo);
+    const response = await adapter.request("GET", repoEndpoint(owner, repo, "/branches"));
+    return asArray(response, "branches").map(mapBranch);
+  });
+}
+async function createBranch(adapter, params) {
+  const { owner, repo } = params;
+  return withActionError(`create GitHub branch ${params.branch} in ${owner}/${repo}`, async () => {
+    assertOwnerRepo(owner, repo);
+    const branch = assertNonEmptyString(params.branch, "branch");
+    const sourceBranch = params.fromBranch ?? await getDefaultBranch(adapter, params);
+    const source = await getBranch(adapter, owner, repo, sourceBranch);
+    const sha = assertNonEmptyString(source.commit.sha, "source branch sha");
+    await adapter.request("POST", repoEndpoint(owner, repo, "/git/refs"), {
+      body: {
+        ref: `refs/heads/${branch}`,
+        sha
+      }
+    });
+  });
+}
+async function getBranch(adapter, owner, repo, branch) {
+  const response = await adapter.request("GET", branchEndpoint(owner, repo, branch));
+  return mapBranch(response);
+}
+function mapBranch(value) {
+  const branch = asRecord(value, "branch");
+  const commit = asRecord(branch.commit, "branch commit");
+  return {
+    name: stringValue(branch.name),
+    commit: {
+      sha: stringValue(commit.sha),
+      url: stringValue(commit.url)
+    },
+    protected: booleanValue(branch.protected)
+  };
+}
+async function getDefaultBranch(adapter, params) {
+  const response = await adapter.request("GET", repoEndpoint(params.owner, params.repo));
+  const repository = asRecord(response, "repository");
+  const branch = stringValue(repository.default_branch);
+  if (!branch) {
+    const id = numberValue(repository.id);
+    throw new Error(
+      id ? `Repository ${params.owner}/${params.repo} did not include a default branch.` : `Repository ${params.owner}/${params.repo} was not a valid repository response.`
+    );
+  }
+  return branch;
+}
+var init_branches = __esm({
+  "packages/github-primitive/src/actions/branches.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// packages/github-primitive/src/actions/commits.ts
+async function listCommits(adapter, params) {
+  const { owner, repo } = params;
+  return withActionError(`list GitHub commits for ${owner}/${repo}`, async () => {
+    assertOwnerRepo(owner, repo);
+    const query = {
+      sha: params.sha,
+      path: params.path,
+      author: params.author,
+      since: params.since,
+      until: params.until,
+      per_page: normalizePerPage(params.perPage)
+    };
+    const response = await adapter.request("GET", repoEndpoint(owner, repo, "/commits"), {
+      query
+    });
+    return asArray(response, "commits").map(mapCommit);
+  });
+}
+async function createCommit(adapter, params) {
+  const { owner, repo } = params;
+  return withActionError(`create GitHub commit in ${owner}/${repo}`, async () => {
+    assertOwnerRepo(owner, repo);
+    const message = assertNonEmptyString(params.message, "commit message");
+    const tree = assertNonEmptyString(params.tree, "commit tree");
+    if (!Array.isArray(params.parents)) {
+      throw new Error("GitHub commit parents must be an array of parent SHAs.");
+    }
+    const response = await adapter.request("POST", repoEndpoint(owner, repo, "/git/commits"), {
+      body: removeUndefinedValues({
+        message,
+        tree,
+        parents: params.parents.map((parent) => assertNonEmptyString(parent, "parent sha")),
+        author: params.author,
+        committer: params.committer
+      })
+    });
+    return mapCommit(response);
+  });
+}
+function mapCommit(value) {
+  const topLevel = asRecord(value, "commit");
+  const nestedCommit = optionalRecord(topLevel.commit);
+  const author = optionalRecord(nestedCommit?.author ?? topLevel.author);
+  const committer = optionalRecord(nestedCommit?.committer ?? topLevel.committer);
+  return {
+    sha: stringValue(topLevel.sha),
+    url: optionalString(topLevel.url),
+    htmlUrl: optionalString(topLevel.html_url),
+    message: optionalString(nestedCommit?.message ?? topLevel.message),
+    author: author ? mapCommitAuthor(author) : void 0,
+    committer: committer ? mapCommitAuthor(committer) : void 0
+  };
+}
+function mapCommitAuthor(value) {
+  return {
+    name: stringValue(value.name),
+    email: stringValue(value.email),
+    date: optionalString(value.date)
+  };
+}
+var init_commits = __esm({
+  "packages/github-primitive/src/actions/commits.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// packages/github-primitive/src/actions/files.ts
+async function listFiles(adapter, owner, repo, path25 = "", options = {}) {
+  return withActionError(`list GitHub files at ${owner}/${repo}/${path25}`, async () => {
+    assertOwnerRepo(owner, repo);
+    const response = await adapter.request("GET", contentsEndpoint(owner, repo, path25), {
+      query: {
+        ref: options.ref
+      }
+    });
+    return Array.isArray(response) ? asArray(response, "repository contents").map(mapFile) : [mapFile(response)];
+  });
+}
+async function readFile3(adapter, owner, repo, path25, ref) {
+  return withActionError(`read GitHub file ${owner}/${repo}/${path25}`, async () => {
+    assertOwnerRepo(owner, repo);
+    assertNonEmptyString(normalizeRepoPath(path25), "file path");
+    const response = await adapter.request("GET", contentsEndpoint(owner, repo, path25), {
+      query: {
+        ref
+      }
+    });
+    const file2 = mapFile(response);
+    if (file2.type !== "file") {
+      throw new Error(`GitHub path "${path25}" is not a file.`);
+    }
+    if (!file2.content) {
+      throw new Error(`GitHub file "${path25}" did not include content in the API response.`);
+    }
+    if (file2.encoding && file2.encoding !== "base64") {
+      throw new Error(`GitHub file "${path25}" used unsupported encoding "${file2.encoding}".`);
+    }
+    return import_node_buffer.Buffer.from(file2.content.replace(/\s/g, ""), "base64").toString("utf8");
+  });
+}
+async function createFile(adapter, owner, repo, path25, content, message, options = {}) {
+  return withActionError(`create GitHub file ${owner}/${repo}/${path25}`, async () => {
+    assertOwnerRepo(owner, repo);
+    const normalizedPath = assertNonEmptyString(normalizeRepoPath(path25), "file path");
+    const commitMessage = assertNonEmptyString(message, "commit message");
+    await adapter.request("PUT", contentsEndpoint(owner, repo, normalizedPath), {
+      body: removeUndefinedValues({
+        message: commitMessage,
+        content: import_node_buffer.Buffer.from(content, "utf8").toString("base64"),
+        branch: options.branch,
+        author: options.author
+      })
+    });
+  });
+}
+async function updateFile(adapter, owner, repo, path25, content, message, sha, options = {}) {
+  return withActionError(`update GitHub file ${owner}/${repo}/${path25}`, async () => {
+    assertOwnerRepo(owner, repo);
+    const normalizedPath = assertNonEmptyString(normalizeRepoPath(path25), "file path");
+    const commitMessage = assertNonEmptyString(message, "commit message");
+    const fileSha = assertNonEmptyString(sha, "file sha");
+    const response = await adapter.request("PUT", contentsEndpoint(owner, repo, normalizedPath), {
+      body: removeUndefinedValues({
+        message: commitMessage,
+        content: import_node_buffer.Buffer.from(content, "utf8").toString("base64"),
+        sha: fileSha,
+        branch: options.branch,
+        author: options.author
+      })
+    });
+    const contentRecord = asRecord(response, "update file response").content;
+    return mapFile(contentRecord);
+  });
+}
+async function deleteFile(adapter, owner, repo, path25, sha, message, options = {}) {
+  return withActionError(`delete GitHub file ${owner}/${repo}/${path25}`, async () => {
+    assertOwnerRepo(owner, repo);
+    const normalizedPath = assertNonEmptyString(normalizeRepoPath(path25), "file path");
+    const fileSha = assertNonEmptyString(sha, "file sha");
+    const commitMessage = assertNonEmptyString(message, "commit message");
+    await adapter.request("DELETE", contentsEndpoint(owner, repo, normalizedPath), {
+      body: removeUndefinedValues({
+        message: commitMessage,
+        sha: fileSha,
+        branch: options.branch,
+        author: options.author
+      })
+    });
+  });
+}
+function mapFile(value) {
+  const file2 = asRecord(value, "repository content");
+  const type = stringValue(file2.type) === "dir" ? "dir" : "file";
+  return {
+    name: stringValue(file2.name),
+    path: stringValue(file2.path),
+    sha: stringValue(file2.sha),
+    size: numberValue(file2.size),
+    url: stringValue(file2.url),
+    htmlUrl: stringValue(file2.html_url),
+    gitUrl: stringValue(file2.git_url),
+    downloadUrl: optionalString(file2.download_url),
+    type,
+    content: optionalString(file2.content),
+    encoding: optionalString(file2.encoding),
+    target: optionalString(file2.target)
+  };
+}
+var import_node_buffer;
+var init_files = __esm({
+  "packages/github-primitive/src/actions/files.ts"() {
+    "use strict";
+    import_node_buffer = require("node:buffer");
+    init_utils();
+  }
+});
+
+// packages/github-primitive/src/actions/issues.ts
+async function listIssues(adapter, owner, repo, options = {}) {
+  return withActionError(`list GitHub issues for ${owner}/${repo}`, async () => {
+    assertOwnerRepo(owner, repo);
+    const query = queryWithPerPage(
+      {
+        state: options.state,
+        assignee: options.assignee,
+        labels: options.labels,
+        sort: options.sort,
+        direction: options.direction
+      },
+      options.perPage
+    );
+    const response = await adapter.request("GET", repoEndpoint(owner, repo, "/issues"), {
+      query
+    });
+    return asArray(response, "issues").filter(isIssueResponse).map(mapIssue);
+  });
+}
+async function createIssue(adapter, owner, repo, title, body, options = {}) {
+  return withActionError(`create GitHub issue in ${owner}/${repo}`, async () => {
+    assertOwnerRepo(owner, repo);
+    const issueTitle = assertNonEmptyString(title, "issue title");
+    const response = await adapter.request("POST", repoEndpoint(owner, repo, "/issues"), {
+      body: removeUndefinedValues({
+        title: issueTitle,
+        body,
+        assignees: options.assignee ? [options.assignee] : void 0,
+        labels: options.labels,
+        milestone: options.milestone
+      })
+    });
+    return mapIssue(response);
+  });
+}
+async function updateIssue(adapter, owner, repo, number4, updates) {
+  return withActionError(`update GitHub issue #${number4} in ${owner}/${repo}`, async () => {
+    assertOwnerRepo(owner, repo);
+    assertPositiveInteger(number4, "issue number");
+    if (!hasDefinedValue(updates)) {
+      throw new Error("At least one issue update field must be provided.");
+    }
+    const response = await adapter.request("PATCH", repoEndpoint(owner, repo, `/issues/${number4}`), {
+      body: removeUndefinedValues({
+        title: updates.title,
+        body: updates.body,
+        state: updates.state,
+        assignees: updates.assignee ? [updates.assignee] : void 0,
+        labels: updates.labels
+      })
+    });
+    return mapIssue(response);
+  });
+}
+function mapIssue(value) {
+  const issue2 = asRecord(value, "issue");
+  const milestone = optionalRecord(issue2.milestone);
+  const reactions = optionalRecord(issue2.reactions);
+  return {
+    number: numberValue(issue2.number),
+    id: numberValue(issue2.id),
+    title: stringValue(issue2.title),
+    body: optionalString(issue2.body),
+    user: mapGitHubOwner(issue2.user),
+    labels: Array.isArray(issue2.labels) ? issue2.labels.map(mapIssueLabel) : [],
+    state: stateValue(issue2.state),
+    locked: booleanValue(issue2.locked),
+    assignee: issue2.assignee ? mapLogin(issue2.assignee) : void 0,
+    assignees: mapLogins(issue2.assignees),
+    milestone: milestone ? {
+      number: numberValue(milestone.number),
+      title: stringValue(milestone.title)
+    } : void 0,
+    commentsCount: numberValue(issue2.comments),
+    createdAt: stringValue(issue2.created_at),
+    updatedAt: stringValue(issue2.updated_at),
+    closedAt: optionalString(issue2.closed_at),
+    authorAssociation: stringValue(issue2.author_association),
+    reactions: {
+      totalCount: numberValue(reactions?.total_count)
+    }
+  };
+}
+function mapIssueLabel(value) {
+  if (typeof value === "string") {
+    return {
+      name: value,
+      color: ""
+    };
+  }
+  const label = asRecord(value, "issue label");
+  return {
+    name: stringValue(label.name),
+    color: stringValue(label.color),
+    description: optionalString(label.description)
+  };
+}
+function isIssueResponse(value) {
+  return !("pull_request" in asRecord(value, "issue"));
+}
+var init_issues = __esm({
+  "packages/github-primitive/src/actions/issues.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// packages/github-primitive/src/actions/pulls.ts
+async function listPRs(adapter, owner, repo, options = {}) {
+  return withActionError(`list GitHub pull requests for ${owner}/${repo}`, async () => {
+    assertOwnerRepo(owner, repo);
+    const query = queryWithPerPage(
+      {
+        state: options.state,
+        base: options.base,
+        head: options.head,
+        sort: options.sort,
+        direction: options.direction
+      },
+      options.perPage
+    );
+    const response = await adapter.request("GET", repoEndpoint(owner, repo, "/pulls"), {
+      query
+    });
+    return asArray(response, "pull requests").map(mapPR);
+  });
+}
+async function getPR(adapter, owner, repo, number4) {
+  return withActionError(`get GitHub pull request #${number4} in ${owner}/${repo}`, async () => {
+    assertOwnerRepo(owner, repo);
+    assertPositiveInteger(number4, "pull request number");
+    const response = await adapter.request("GET", repoEndpoint(owner, repo, `/pulls/${number4}`));
+    return mapPR(response);
+  });
+}
+async function createPR(adapter, owner, repo, title, body, base, head, options = {}) {
+  return withActionError(`create GitHub pull request in ${owner}/${repo}`, async () => {
+    assertOwnerRepo(owner, repo);
+    const prTitle = assertNonEmptyString(title, "pull request title");
+    const baseRef = assertNonEmptyString(base, "pull request base");
+    const headRef = assertNonEmptyString(head, "pull request head");
+    const response = await adapter.request("POST", repoEndpoint(owner, repo, "/pulls"), {
+      body: removeUndefinedValues({
+        title: prTitle,
+        body,
+        base: baseRef,
+        head: headRef,
+        draft: options.draft,
+        maintainer_can_modify: options.maintainerCanModify
+      })
+    });
+    return mapPR(response);
+  });
+}
+async function updatePR(adapter, owner, repo, number4, updates) {
+  return withActionError(`update GitHub pull request #${number4} in ${owner}/${repo}`, async () => {
+    assertOwnerRepo(owner, repo);
+    assertPositiveInteger(number4, "pull request number");
+    if (!hasDefinedValue(updates)) {
+      throw new Error("At least one pull request update field must be provided.");
+    }
+    const response = await adapter.request("PATCH", repoEndpoint(owner, repo, `/pulls/${number4}`), {
+      body: removeUndefinedValues({
+        title: updates.title,
+        body: updates.body,
+        state: updates.state,
+        base: updates.base,
+        maintainer_can_modify: updates.maintainerCanModify
+      })
+    });
+    return mapPR(response);
+  });
+}
+async function mergePR(adapter, owner, repo, number4, options = {}) {
+  return withActionError(`merge GitHub pull request #${number4} in ${owner}/${repo}`, async () => {
+    assertOwnerRepo(owner, repo);
+    assertPositiveInteger(number4, "pull request number");
+    await adapter.request("PUT", repoEndpoint(owner, repo, `/pulls/${number4}/merge`), {
+      body: removeUndefinedValues({
+        commit_title: options.commitTitle,
+        commit_message: options.commitMessage,
+        merge_method: options.mergeMethod
+      })
+    });
+    return getPR(adapter, owner, repo, number4);
+  });
+}
+function mapPR(value) {
+  const pull = asRecord(value, "pull request");
+  const base = asRecord(pull.base, "pull request base");
+  const head = asRecord(pull.head, "pull request head");
+  const baseRepo = optionalRecord(base.repo);
+  const headRepo = optionalRecord(head.repo);
+  return {
+    number: numberValue(pull.number),
+    id: numberValue(pull.id),
+    title: stringValue(pull.title),
+    body: optionalString(pull.body),
+    user: mapGitHubOwner(pull.user),
+    state: stateValue(pull.state),
+    draft: booleanValue(pull.draft),
+    locked: booleanValue(pull.locked),
+    mergeable: typeof pull.mergeable === "boolean" ? pull.mergeable : void 0,
+    mergeableState: stringValue(pull.mergeable_state),
+    merged: booleanValue(pull.merged),
+    mergedAt: optionalString(pull.merged_at),
+    mergedBy: pull.merged_by ? mapLogin(pull.merged_by) : void 0,
+    base: {
+      ref: stringValue(base.ref),
+      sha: stringValue(base.sha),
+      repo: {
+        name: stringValue(baseRepo?.name),
+        fullName: stringValue(baseRepo?.full_name)
+      }
+    },
+    head: {
+      ref: stringValue(head.ref),
+      sha: stringValue(head.sha),
+      repo: headRepo ? {
+        name: stringValue(headRepo.name),
+        fullName: stringValue(headRepo.full_name)
+      } : void 0
+    },
+    requestedReviewers: mapLogins(pull.requested_reviewers),
+    labels: Array.isArray(pull.labels) ? pull.labels.map(mapPullLabel) : [],
+    commentsCount: numberValue(pull.comments),
+    reviewCommentsCount: numberValue(pull.review_comments),
+    commitsCount: numberValue(pull.commits),
+    additionsCount: numberValue(pull.additions),
+    deletionsCount: numberValue(pull.deletions),
+    changedFilesCount: numberValue(pull.changed_files),
+    createdAt: stringValue(pull.created_at),
+    updatedAt: stringValue(pull.updated_at)
+  };
+}
+function mapPullLabel(value) {
+  if (typeof value === "string") {
+    return {
+      name: value,
+      color: ""
+    };
+  }
+  const label = asRecord(value, "pull request label");
+  return {
+    name: stringValue(label.name),
+    color: stringValue(label.color)
+  };
+}
+var init_pulls = __esm({
+  "packages/github-primitive/src/actions/pulls.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// packages/github-primitive/src/actions/repos.ts
+async function listRepos(adapter, options = {}) {
+  return withActionError("list GitHub repositories", async () => {
+    const query = queryWithPerPage(
+      {
+        visibility: options.visibility,
+        affiliation: options.affiliation,
+        sort: options.sort,
+        direction: options.direction
+      },
+      options.perPage
+    );
+    const response = await adapter.request("GET", "/user/repos", { query });
+    return asArray(response, "repositories").map(mapRepo);
+  });
+}
+async function getRepo(adapter, owner, repo) {
+  return withActionError(`get GitHub repository ${owner}/${repo}`, async () => {
+    const response = await adapter.request("GET", repoEndpoint(owner, repo));
+    return mapRepo(response);
+  });
+}
+function mapRepo(value) {
+  const repo = asRecord(value, "repository");
+  const isPrivate = booleanValue(repo.private);
+  const permissions = optionalRecord(repo.permissions);
+  return {
+    id: numberValue(repo.id),
+    name: stringValue(repo.name),
+    fullName: stringValue(repo.full_name, stringValue(repo.name)),
+    owner: mapGitHubOwner(repo.owner),
+    description: optionalString(repo.description),
+    private: isPrivate,
+    fork: booleanValue(repo.fork),
+    createdAt: stringValue(repo.created_at),
+    updatedAt: stringValue(repo.updated_at),
+    pushedAt: stringValue(repo.pushed_at),
+    size: numberValue(repo.size),
+    stargazersCount: numberValue(repo.stargazers_count),
+    watchersCount: numberValue(repo.watchers_count),
+    language: optionalString(repo.language),
+    forksCount: numberValue(repo.forks_count),
+    openIssuesCount: numberValue(repo.open_issues_count),
+    defaultBranch: stringValue(repo.default_branch),
+    topics: Array.isArray(repo.topics) ? repo.topics.filter(isString) : [],
+    visibility: visibilityValue(repo.visibility, isPrivate),
+    permissions: permissions ? {
+      admin: booleanValue(permissions.admin),
+      maintain: booleanValue(permissions.maintain),
+      push: booleanValue(permissions.push),
+      triage: booleanValue(permissions.triage),
+      pull: booleanValue(permissions.pull)
+    } : void 0
+  };
+}
+function isString(value) {
+  return typeof value === "string";
+}
+var init_repos = __esm({
+  "packages/github-primitive/src/actions/repos.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// packages/github-primitive/src/actions/users.ts
+async function getUser(adapter, params = {}) {
+  return withActionError("get GitHub user", async () => {
+    const path25 = params.username ? `/users/${encodeURIComponent(assertNonEmptyString(params.username, "username"))}` : "/user";
+    const response = await adapter.request("GET", path25);
+    return mapUser(response);
+  });
+}
+async function listOrganizations(adapter, params = {}) {
+  return withActionError("list GitHub organizations", async () => {
+    const path25 = params.username ? `/users/${encodeURIComponent(assertNonEmptyString(params.username, "username"))}/orgs` : "/user/orgs";
+    const response = await adapter.request("GET", path25, {
+      query: queryWithPerPage({}, params.perPage)
+    });
+    return asArray(response, "organizations").map(mapOrganization);
+  });
+}
+function mapUser(value) {
+  const user = asRecord(value, "user");
+  const login = stringValue(user.login);
+  if (!login) {
+    throw new Error("GitHub user response did not include a login.");
+  }
+  return {
+    login,
+    name: optionalString(user.name),
+    id: numberValue(user.id),
+    type: optionalString(user.type)
+  };
+}
+function mapOrganization(value) {
+  const organization = asRecord(value, "organization");
+  return {
+    login: stringValue(organization.login),
+    id: numberValue(organization.id),
+    description: optionalString(organization.description),
+    url: optionalString(organization.url),
+    avatarUrl: optionalString(organization.avatar_url)
+  };
+}
+var init_users = __esm({
+  "packages/github-primitive/src/actions/users.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// packages/github-primitive/src/local-runtime.ts
+var local_runtime_exports = {};
+__export(local_runtime_exports, {
+  GhCliClient: () => GhCliClient,
+  GhCliError: () => GhCliError
+});
+var import_node_child_process10, GhCliError, GhCliClient;
+var init_local_runtime = __esm({
+  "packages/github-primitive/src/local-runtime.ts"() {
+    "use strict";
+    import_node_child_process10 = require("node:child_process");
+    init_adapter();
+    init_utils();
+    init_types();
+    GhCliError = class extends Error {
+      command;
+      args;
+      exitCode;
+      stdout;
+      stderr;
+      cause;
+      constructor(message, options) {
+        super(message);
+        this.name = "GhCliError";
+        this.command = options.command;
+        this.args = options.args;
+        this.exitCode = options.exitCode;
+        this.stdout = options.stdout ?? "";
+        this.stderr = options.stderr ?? "";
+        this.cause = options.cause;
+      }
+    };
+    GhCliClient = class extends BaseGitHubAdapter {
+      constructor(config2 = {}) {
+        super({
+          ...config2,
+          runtime: "local"
+        });
+      }
+      getRuntime() {
+        return "local";
+      }
+      async isAuthenticated() {
+        try {
+          await this.runGhCommand(["auth", "status"], {
+            parseJson: false,
+            timeout: Math.min(this.config.timeout, 1e4)
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async getCurrentUser() {
+        const user = await this.request("GET", "/user");
+        if (!user.login) {
+          throw new GitHubApiError("GitHub user response did not include a login.");
+        }
+        return {
+          login: user.login,
+          name: user.name ?? void 0,
+          id: user.id,
+          type: user.type
+        };
+      }
+      async request(method, path25, options = {}) {
+        return this.executeWithRetries(async () => {
+          const request = this.buildApiCommand(method, path25, options);
+          const result = await this.runGhCommand(request.args, {
+            input: request.input,
+            parseJson: true,
+            allowEmpty: true,
+            timeout: options.timeout ?? this.config.timeout,
+            signal: options.signal
+          });
+          return result.data;
+        });
+      }
+      runGhCommand(args, options = {}) {
+        const command = this.config.ghPath;
+        const timeout = options.timeout ?? this.config.timeout;
+        const env = {
+          ...process.env,
+          ...this.config.env,
+          ...options.env
+        };
+        return new Promise((resolve4, reject) => {
+          const child = (0, import_node_child_process10.spawn)(command, args, {
+            cwd: options.cwd ?? this.config.cwd,
+            env,
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          let stdout = "";
+          let stderr = "";
+          let finished = false;
+          const finish = (callback) => {
+            if (finished) {
+              return;
+            }
+            finished = true;
+            clearTimeout(timer);
+            options.signal?.removeEventListener("abort", abort);
+            callback();
+          };
+          const rejectWith = (error51) => {
+            finish(() => reject(error51));
+          };
+          const abort = () => {
+            child.kill("SIGTERM");
+            rejectWith(
+              new GhCliError(`gh command aborted: ${command} ${args.join(" ")}`, {
+                command,
+                args,
+                stdout,
+                stderr
+              })
+            );
+          };
+          const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            rejectWith(
+              new GhCliError(`gh command timed out after ${timeout}ms: ${command} ${args.join(" ")}`, {
+                command,
+                args,
+                stdout,
+                stderr
+              })
+            );
+          }, timeout);
+          if (options.signal?.aborted) {
+            abort();
+            return;
+          }
+          options.signal?.addEventListener("abort", abort, { once: true });
+          child.stdout.setEncoding("utf8");
+          child.stderr.setEncoding("utf8");
+          child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+          });
+          child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+          });
+          child.on("error", (error51) => {
+            rejectWith(
+              new GhCliError(`Failed to start gh command: ${error51.message}`, {
+                command,
+                args,
+                stdout,
+                stderr,
+                cause: error51
+              })
+            );
+          });
+          child.on("close", (exitCode) => {
+            if (finished) {
+              return;
+            }
+            if (exitCode !== 0) {
+              rejectWith(
+                new GhCliError(stderr.trim() || `gh command failed with exit code ${exitCode}`, {
+                  command,
+                  args,
+                  exitCode: exitCode ?? void 0,
+                  stdout,
+                  stderr
+                })
+              );
+              return;
+            }
+            try {
+              const data = this.parseCommandOutput(stdout, options);
+              finish(
+                () => resolve4({
+                  args,
+                  command,
+                  exitCode: exitCode ?? 0,
+                  stdout,
+                  stderr,
+                  data
+                })
+              );
+            } catch (error51) {
+              rejectWith(
+                new GhCliError(error51 instanceof Error ? error51.message : String(error51), {
+                  command,
+                  args,
+                  exitCode: exitCode ?? void 0,
+                  stdout,
+                  stderr,
+                  cause: error51
+                })
+              );
+            }
+          });
+          if (typeof options.input === "string") {
+            child.stdin.end(options.input);
+          } else {
+            child.stdin.end();
+          }
+        });
+      }
+      buildApiCommand(method, path25, options) {
+        const args = [
+          "api",
+          appendQuery(path25, options.query),
+          "--method",
+          method,
+          "--header",
+          "Accept: application/vnd.github+json",
+          "--header",
+          "X-GitHub-Api-Version: 2022-11-28"
+        ];
+        for (const [name, value] of Object.entries(options.headers ?? {})) {
+          args.push("--header", `${name}: ${value}`);
+        }
+        if (typeof options.body !== "undefined") {
+          args.push("--input", "-");
+          return {
+            args,
+            input: JSON.stringify(options.body)
+          };
+        }
+        return { args };
+      }
+      parseCommandOutput(stdout, options) {
+        if (options.parseJson === false) {
+          return stdout;
+        }
+        const trimmed = stdout.trim();
+        if (!trimmed) {
+          if (options.allowEmpty) {
+            return void 0;
+          }
+          throw new Error("gh command returned empty output where JSON was expected.");
+        }
+        try {
+          return JSON.parse(trimmed);
+        } catch (error51) {
+          throw new Error(
+            `Failed to parse gh JSON output: ${error51 instanceof Error ? error51.message : String(error51)}`
+          );
+        }
+      }
+    };
+  }
+});
+
+// packages/github-primitive/src/cloud-runtime.ts
+var cloud_runtime_exports = {};
+__export(cloud_runtime_exports, {
+  NangoClient: () => NangoClient
+});
+async function parseJsonResponse(response) {
+  const text = await response.text();
+  if (!response.ok) {
+    throw new GitHubApiError(
+      text || `GitHub API request failed with ${response.status} ${response.statusText}`,
+      {
+        status: response.status,
+        responseBody: text,
+        responseHeaders: headersToRecord(response.headers)
+      }
+    );
+  }
+  if (!text.trim()) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error51) {
+    throw new GitHubApiError(
+      `Failed to parse GitHub API JSON response: ${error51 instanceof Error ? error51.message : String(error51)}`,
+      {
+        status: response.status,
+        responseBody: text,
+        responseHeaders: headersToRecord(response.headers),
+        cause: error51
+      }
+    );
+  }
+}
+function buildNangoProxyUrl(baseUrl, path25, query) {
+  const base = trimTrailingSlash(baseUrl) ?? DEFAULT_NANGO_BASE_URL;
+  const endpoint = stripLeadingSlash(path25);
+  return appendQuery(`${base}/proxy/${endpoint}`, query);
+}
+function joinUrl(baseUrl, path25) {
+  return `${trimTrailingSlash(baseUrl) ?? baseUrl}/${stripLeadingSlash(path25)}`;
+}
+function stripLeadingSlash(value) {
+  return value.replace(/^\/+/, "");
+}
+function headersToRecord(headers) {
+  const record2 = {};
+  headers.forEach((value, key) => {
+    record2[key] = value;
+  });
+  return record2;
+}
+function errorMessage2(error51) {
+  return error51 instanceof Error ? error51.message : String(error51);
+}
+var NangoClient;
+var init_cloud_runtime = __esm({
+  "packages/github-primitive/src/cloud-runtime.ts"() {
+    "use strict";
+    init_adapter();
+    init_utils();
+    init_constants();
+    init_types();
+    NangoClient = class extends BaseGitHubAdapter {
+      lastNangoFallbackError;
+      constructor(config2 = {}) {
+        super({
+          ...config2,
+          runtime: "cloud"
+        });
+      }
+      getRuntime() {
+        return "cloud";
+      }
+      async isAuthenticated() {
+        try {
+          await this.getCurrentUser();
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async getCurrentUser() {
+        const user = await this.request("GET", "/user");
+        if (!user.login) {
+          throw new GitHubApiError("GitHub user response did not include a login.");
+        }
+        return {
+          login: user.login,
+          name: user.name ?? void 0,
+          id: user.id,
+          type: user.type
+        };
+      }
+      async request(method, path25, options = {}) {
+        return this.executeWithRetries(async () => {
+          if (this.hasNangoCredentials()) {
+            try {
+              return await this.requestViaNango(method, path25, options);
+            } catch (error51) {
+              if (!this.hasRelayCloudCredentials()) {
+                throw error51;
+              }
+              this.lastNangoFallbackError = error51;
+              try {
+                return await this.requestViaRelayCloud(method, path25, options);
+              } catch (relayError) {
+                throw new GitHubApiError(
+                  `Nango GitHub proxy failed, then relay-cloud fallback failed: ${errorMessage2(relayError)}`,
+                  {
+                    cause: {
+                      nango: error51,
+                      relayCloud: relayError
+                    }
+                  }
+                );
+              }
+            }
+          }
+          if (this.hasRelayCloudCredentials()) {
+            return this.requestViaRelayCloud(method, path25, options);
+          }
+          throw new GitHubApiError(
+            "Cloud GitHub runtime requires Nango credentials or relay-cloud proxy configuration."
+          );
+        });
+      }
+      /**
+       * Returns the most recent Nango failure that triggered a relay-cloud fallback.
+       */
+      getLastNangoFallbackError() {
+        return this.lastNangoFallbackError;
+      }
+      async requestViaNango(method, path25, options) {
+        const secretKey = this.config.nango.secretKey;
+        const connectionId = this.config.nango.connectionId;
+        const providerConfigKey = this.config.nango.providerConfigKey;
+        if (!secretKey || !connectionId || !providerConfigKey) {
+          throw new GitHubApiError("Nango GitHub proxy requires secretKey, connectionId, and providerConfigKey.");
+        }
+        const url2 = buildNangoProxyUrl(this.config.nango.baseUrl, path25, options.query);
+        const response = await this.fetchWithTimeout(url2, {
+          method,
+          headers: {
+            Authorization: `Bearer ${secretKey}`,
+            "Connection-Id": connectionId,
+            "Provider-Config-Key": providerConfigKey,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": this.config.userAgent,
+            ...options.headers
+          },
+          body: typeof options.body === "undefined" ? void 0 : JSON.stringify(options.body),
+          signal: options.signal,
+          timeout: options.timeout
+        });
+        return parseJsonResponse(response);
+      }
+      async requestViaRelayCloud(method, path25, options) {
+        const apiUrl = this.config.relayCloud.apiUrl;
+        const accessToken = this.config.relayCloud.accessToken;
+        const endpoint = this.config.relayCloud.endpoint ?? DEFAULT_RELAY_CLOUD_GITHUB_PROXY_ENDPOINT;
+        if (!apiUrl || !accessToken) {
+          throw new GitHubApiError("Relay cloud GitHub proxy requires apiUrl and accessToken configuration.");
+        }
+        const payload = {
+          method,
+          path: path25,
+          query: options.query,
+          body: options.body,
+          headers: options.headers,
+          nango: {
+            connectionId: this.config.nango.connectionId,
+            providerConfigKey: this.config.nango.providerConfigKey
+          }
+        };
+        const response = await this.fetchWithTimeout(joinUrl(apiUrl, endpoint), {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": this.config.userAgent,
+            ...this.config.relayCloud.workspaceId ? { "X-Relay-Workspace-Id": this.config.relayCloud.workspaceId } : {}
+          },
+          body: JSON.stringify(payload),
+          signal: options.signal,
+          timeout: options.timeout
+        });
+        const result = await parseJsonResponse(response);
+        if (typeof result === "object" && result !== null && "data" in result && Object.keys(result).some((key) => key === "data")) {
+          return result.data;
+        }
+        return result;
+      }
+      async fetchWithTimeout(input, init) {
+        const fetchImpl = this.config.fetch ?? fetch;
+        const timeout = init.timeout ?? this.config.timeout;
+        const signal = init.signal ?? AbortSignal.timeout(timeout);
+        const { timeout: _timeout, ...requestInit } = init;
+        return fetchImpl(input, {
+          ...requestInit,
+          signal
+        });
+      }
+      hasNangoCredentials() {
+        return Boolean(
+          this.config.nango.secretKey && this.config.nango.connectionId && this.config.nango.providerConfigKey
+        );
+      }
+      hasRelayCloudCredentials() {
+        return Boolean(this.config.relayCloud.apiUrl && this.config.relayCloud.accessToken);
+      }
+    };
+  }
+});
+
+// packages/github-primitive/src/adapter.ts
+function normalizeGitHubRuntimeConfig(config2 = {}) {
+  const env = config2.env ?? process.env;
+  const nango = config2.nango ?? {};
+  const relayCloud = config2.relayCloud ?? {};
+  return {
+    ...config2,
+    runtime: config2.runtime ?? "auto",
+    ghPath: nonEmpty(config2.ghPath) ?? nonEmpty(env.GH_PATH) ?? DEFAULT_GH_PATH,
+    cwd: config2.cwd,
+    env,
+    timeout: config2.timeout ?? DEFAULT_TIMEOUT,
+    retryOnRateLimit: config2.retryOnRateLimit ?? true,
+    maxRetries: config2.maxRetries ?? DEFAULT_MAX_RETRIES,
+    userAgent: config2.userAgent ?? DEFAULT_USER_AGENT,
+    fetch: config2.fetch,
+    nango: {
+      connectionId: nonEmpty(nango.connectionId) ?? nonEmpty(env.NANGO_GITHUB_CONNECTION_ID) ?? nonEmpty(env.GITHUB_NANGO_CONNECTION_ID) ?? nonEmpty(env.NANGO_CONNECTION_ID),
+      providerConfigKey: nonEmpty(nango.providerConfigKey) ?? nonEmpty(env.NANGO_GITHUB_PROVIDER_CONFIG_KEY) ?? nonEmpty(env.GITHUB_NANGO_PROVIDER_CONFIG_KEY) ?? nonEmpty(env.NANGO_PROVIDER_CONFIG_KEY) ?? DEFAULT_NANGO_PROVIDER_CONFIG_KEY,
+      secretKey: nonEmpty(nango.secretKey) ?? nonEmpty(env.NANGO_SECRET_KEY),
+      baseUrl: trimTrailingSlash(nonEmpty(nango.baseUrl) ?? nonEmpty(env.NANGO_HOST)) ?? DEFAULT_NANGO_BASE_URL
+    },
+    relayCloud: {
+      apiUrl: trimTrailingSlash(
+        nonEmpty(relayCloud.apiUrl) ?? nonEmpty(env.RELAY_CLOUD_API_URL) ?? nonEmpty(env.CLOUD_API_URL)
+      ) ?? void 0,
+      accessToken: nonEmpty(relayCloud.accessToken) ?? nonEmpty(env.RELAY_CLOUD_API_TOKEN) ?? nonEmpty(env.CLOUD_API_ACCESS_TOKEN) ?? nonEmpty(env.WORKSPACE_TOKEN),
+      workspaceId: nonEmpty(relayCloud.workspaceId) ?? nonEmpty(env.WORKSPACE_ID),
+      workspaceToken: nonEmpty(relayCloud.workspaceToken) ?? nonEmpty(env.WORKSPACE_TOKEN),
+      endpoint: nonEmpty(relayCloud.endpoint) ?? nonEmpty(env.RELAY_CLOUD_GITHUB_PROXY_ENDPOINT) ?? DEFAULT_RELAY_CLOUD_GITHUB_PROXY_ENDPOINT
+    }
+  };
+}
+function detectGitHubRuntime(config2 = {}) {
+  return GitHubRuntimeDetector.detect(config2);
+}
+function createGitHubAdapter(config2 = {}) {
+  return GitHubAdapterFactory.create(config2);
+}
+async function testLocalRuntime(config2) {
+  try {
+    const { stdout } = await execFileAsync2(config2.ghPath, ["--version"], {
+      cwd: config2.cwd,
+      env: config2.env,
+      timeout: Math.min(config2.timeout, 5e3),
+      maxBuffer: 1024 * 1024
+    });
+    const version2 = String(stdout).split("\n")[0]?.trim();
+    return {
+      runtime: "local",
+      available: true,
+      reason: version2 ? `gh CLI available: ${version2}` : "gh CLI available.",
+      details: version2 ? { version: version2 } : void 0
+    };
+  } catch (error51) {
+    return {
+      runtime: "local",
+      available: false,
+      reason: `gh CLI was not available at "${config2.ghPath}".`,
+      error: errorMessage3(error51)
+    };
+  }
+}
+async function testCloudRuntime(config2) {
+  if (hasNangoConfig(config2)) {
+    return {
+      runtime: "cloud",
+      available: true,
+      reason: "Nango configuration is available.",
+      details: {
+        providerConfigKey: config2.nango.providerConfigKey ?? DEFAULT_NANGO_PROVIDER_CONFIG_KEY,
+        hasConnectionId: Boolean(config2.nango.connectionId)
+      }
+    };
+  }
+  if (hasRelayCloudConfig(config2)) {
+    return {
+      runtime: "cloud",
+      available: true,
+      reason: "Relay cloud API configuration is available.",
+      details: {
+        endpoint: config2.relayCloud.endpoint ?? DEFAULT_RELAY_CLOUD_GITHUB_PROXY_ENDPOINT,
+        hasWorkspaceId: Boolean(config2.relayCloud.workspaceId)
+      }
+    };
+  }
+  return {
+    runtime: "cloud",
+    available: false,
+    reason: "No Nango or relay-cloud GitHub proxy configuration was found."
+  };
+}
+function detectionResult(input) {
+  return {
+    runtime: input.runtime,
+    requestedRuntime: input.requestedRuntime,
+    source: input.source,
+    available: input.selected.available,
+    reason: input.reason,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    local: input.local,
+    cloud: input.cloud
+  };
+}
+function hasNangoConfig(config2) {
+  return Boolean(config2.nango.secretKey);
+}
+function hasRelayCloudConfig(config2) {
+  return Boolean(config2.relayCloud.apiUrl && config2.relayCloud.accessToken);
+}
+function hasCloudEnvironment(env) {
+  return Boolean(
+    env.WORKSPACE_ID || env.CLOUD_API_URL || env.VERCEL || env.RAILWAY_ENVIRONMENT || env.FLY_APP_NAME || env.AWS_REGION || env.GOOGLE_CLOUD_PROJECT || env.NODE_ENV === "production"
+  );
+}
+function statusFromError(error51) {
+  if (error51 instanceof GitHubApiError) {
+    return error51.status;
+  }
+  if (typeof error51 === "object" && error51 !== null && "status" in error51) {
+    const status = error51.status;
+    return typeof status === "number" ? status : void 0;
+  }
+  return void 0;
+}
+function resetHeaderFromError(error51) {
+  const headers = error51 instanceof GitHubApiError ? error51.responseHeaders : typeof error51 === "object" && error51 !== null && "responseHeaders" in error51 ? error51.responseHeaders : void 0;
+  return headers?.["x-ratelimit-reset"] ?? headers?.["X-RateLimit-Reset"];
+}
+function stringifyOutput(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "undefined") {
+    return "";
+  }
+  return JSON.stringify(value);
+}
+function errorMessage3(error51) {
+  return error51 instanceof Error ? error51.message : String(error51);
+}
+function delay3(ms2) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms2);
+  });
+}
+var import_node_child_process11, import_node_util4, execFileAsync2, GitHubRuntimeDetector, BaseGitHubAdapter, GitHubAdapterFactory, GitHubClientFactory;
+var init_adapter = __esm({
+  "packages/github-primitive/src/adapter.ts"() {
+    "use strict";
+    import_node_child_process11 = require("node:child_process");
+    import_node_util4 = require("node:util");
+    init_branches();
+    init_commits();
+    init_files();
+    init_issues();
+    init_pulls();
+    init_repos();
+    init_users();
+    init_utils();
+    init_constants();
+    init_types();
+    execFileAsync2 = (0, import_node_util4.promisify)(import_node_child_process11.execFile);
+    GitHubRuntimeDetector = class {
+      static async detect(config2 = {}) {
+        const normalized = normalizeGitHubRuntimeConfig(config2);
+        const [local, cloud] = await Promise.all([
+          this.testRuntime("local", normalized),
+          this.testRuntime("cloud", normalized)
+        ]);
+        const requestedRuntime = normalized.runtime;
+        if (requestedRuntime === "local" || requestedRuntime === "cloud") {
+          const selected = requestedRuntime === "local" ? local : cloud;
+          return detectionResult({
+            runtime: requestedRuntime,
+            requestedRuntime,
+            source: "config",
+            selected,
+            local,
+            cloud,
+            reason: selected.available ? `Runtime explicitly configured as ${requestedRuntime}.` : `Runtime explicitly configured as ${requestedRuntime}, but availability check failed: ${selected.reason}`
+          });
+        }
+        if (hasNangoConfig(normalized)) {
+          return detectionResult({
+            runtime: "cloud",
+            requestedRuntime,
+            source: "nango",
+            selected: cloud,
+            local,
+            cloud,
+            reason: cloud.available ? "Using cloud runtime because Nango configuration is available." : `Cloud runtime selected from Nango configuration, but availability check failed: ${cloud.reason}`
+          });
+        }
+        if (hasCloudEnvironment(normalized.env)) {
+          if (cloud.available) {
+            return detectionResult({
+              runtime: "cloud",
+              requestedRuntime,
+              source: "environment",
+              selected: cloud,
+              local,
+              cloud,
+              reason: "Using cloud runtime because a cloud workspace or deployment environment was detected."
+            });
+          }
+          if (local.available) {
+            return detectionResult({
+              runtime: "local",
+              requestedRuntime,
+              source: "gh-cli",
+              selected: local,
+              local,
+              cloud,
+              reason: "Cloud environment was detected, but cloud credentials were unavailable; using local gh CLI."
+            });
+          }
+        }
+        if (local.available) {
+          return detectionResult({
+            runtime: "local",
+            requestedRuntime,
+            source: "gh-cli",
+            selected: local,
+            local,
+            cloud,
+            reason: "Using local runtime because gh CLI is available."
+          });
+        }
+        return detectionResult({
+          runtime: "cloud",
+          requestedRuntime,
+          source: "fallback",
+          selected: cloud,
+          local,
+          cloud,
+          reason: cloud.available ? "Using cloud runtime because local gh CLI was unavailable." : "Falling back to cloud runtime because local gh CLI was unavailable; cloud credentials may still be required."
+        });
+      }
+      static async testRuntime(runtime, config2 = {}) {
+        const normalized = normalizeGitHubRuntimeConfig(config2);
+        if (runtime === "local") {
+          return testLocalRuntime(normalized);
+        }
+        return testCloudRuntime(normalized);
+      }
+      static async detectRuntime(config2 = {}) {
+        const result = await this.detect(config2);
+        return result.runtime;
+      }
+    };
+    BaseGitHubAdapter = class extends GitHubClientInterface {
+      retryUsed = false;
+      constructor(config2 = {}) {
+        super(normalizeGitHubRuntimeConfig(config2));
+      }
+      async executeAction(action, params) {
+        const startedAt = Date.now();
+        this.retryUsed = false;
+        try {
+          const data = await this.dispatchAction(action, params);
+          return {
+            success: true,
+            output: stringifyOutput(data),
+            data,
+            metadata: {
+              runtime: this.getRuntime(),
+              executionTime: Date.now() - startedAt,
+              retried: this.retryUsed
+            }
+          };
+        } catch (error51) {
+          return {
+            success: false,
+            output: "",
+            error: errorMessage3(error51),
+            metadata: {
+              runtime: this.getRuntime(),
+              executionTime: Date.now() - startedAt,
+              retried: this.retryUsed
+            }
+          };
+        }
+      }
+      async listRepositories(params = {}) {
+        return listRepos(this, params);
+      }
+      async getRepository(params) {
+        return getRepo(this, params.owner, params.repo);
+      }
+      async listIssues(params) {
+        const { owner, repo, ...options } = params;
+        return listIssues(this, owner, repo, options);
+      }
+      async createIssue(params) {
+        const { owner, repo, title, body, ...options } = params;
+        return createIssue(this, owner, repo, title, body, options);
+      }
+      async updateIssue(params) {
+        const { owner, repo, issueNumber, ...updates } = params;
+        return updateIssue(this, owner, repo, issueNumber, updates);
+      }
+      async closeIssue(params) {
+        return updateIssue(this, params.owner, params.repo, params.issueNumber, {
+          state: "closed"
+        });
+      }
+      async listPullRequests(params) {
+        const { owner, repo, ...options } = params;
+        return listPRs(this, owner, repo, options);
+      }
+      async getPullRequest(params) {
+        return getPR(this, params.owner, params.repo, params.pullNumber);
+      }
+      async createPullRequest(params) {
+        const { owner, repo, title, body, base, head, ...options } = params;
+        return createPR(this, owner, repo, title, body, base, head, options);
+      }
+      async updatePullRequest(params) {
+        const { owner, repo, pullNumber, ...updates } = params;
+        return updatePR(this, owner, repo, pullNumber, updates);
+      }
+      async mergePullRequest(params) {
+        const { owner, repo, pullNumber, ...options } = params;
+        return mergePR(this, owner, repo, pullNumber, options);
+      }
+      async listFiles(params) {
+        const { owner, repo, path: path25, ...options } = params;
+        return listFiles(this, owner, repo, path25, options);
+      }
+      async readFile(params) {
+        return readFile3(this, params.owner, params.repo, params.path, params.ref);
+      }
+      async createFile(params) {
+        const { owner, repo, path: path25, content, message, ...options } = params;
+        return createFile(this, owner, repo, path25, content, message, options);
+      }
+      async updateFile(params) {
+        const { owner, repo, path: path25, content, message, sha, ...options } = params;
+        return updateFile(this, owner, repo, path25, content, message, sha, options);
+      }
+      async deleteFile(params) {
+        const { owner, repo, path: path25, sha, message, ...options } = params;
+        return deleteFile(this, owner, repo, path25, sha, message, options);
+      }
+      async listBranches(params) {
+        return listBranches(this, params.owner, params.repo);
+      }
+      async createBranch(params) {
+        return createBranch(this, params);
+      }
+      async listCommits(params) {
+        return listCommits(this, params);
+      }
+      async createCommit(params) {
+        return createCommit(this, params);
+      }
+      async getUser(params) {
+        return getUser(this, params);
+      }
+      async listOrganizations(params) {
+        return listOrganizations(this, params);
+      }
+      async executeWithRetries(operation) {
+        const maxRetries = this.config.retryOnRateLimit ? this.config.maxRetries : 0;
+        let attempt = 0;
+        while (true) {
+          try {
+            return await operation();
+          } catch (error51) {
+            if (attempt >= maxRetries || !this.isRetryableError(error51)) {
+              throw error51;
+            }
+            attempt += 1;
+            this.retryUsed = true;
+            await delay3(this.retryDelayMs(attempt, error51));
+          }
+        }
+      }
+      isRetryableError(error51) {
+        const status = statusFromError(error51);
+        return status === 403 || status === 429 || typeof status === "number" && status >= 500;
+      }
+      retryDelayMs(attempt, error51) {
+        const reset = resetHeaderFromError(error51);
+        if (reset) {
+          const resetMs = Number(reset) * 1e3;
+          if (Number.isFinite(resetMs) && resetMs > Date.now()) {
+            return Math.min(resetMs - Date.now(), 6e4);
+          }
+        }
+        return Math.min(500 * 2 ** (attempt - 1), 1e4);
+      }
+      async dispatchAction(action, params) {
+        switch (action) {
+          case "listRepos" /* ListRepos */:
+            return this.listRepositories(params);
+          case "getRepo" /* GetRepo */:
+            return this.getRepository(params);
+          case "listIssues" /* ListIssues */:
+            return this.listIssues(params);
+          case "createIssue" /* CreateIssue */:
+            return this.createIssue(params);
+          case "updateIssue" /* UpdateIssue */:
+            return this.updateIssue(params);
+          case "closeIssue" /* CloseIssue */:
+            return this.closeIssue(params);
+          case "listPRs" /* ListPRs */:
+            return this.listPullRequests(params);
+          case "getPR" /* GetPR */:
+            return this.getPullRequest(params);
+          case "createPR" /* CreatePR */:
+            return this.createPullRequest(params);
+          case "updatePR" /* UpdatePR */:
+            return this.updatePullRequest(params);
+          case "mergePR" /* MergePR */:
+            return this.mergePullRequest(params);
+          case "listFiles" /* ListFiles */:
+            return this.listFiles(params);
+          case "readFile" /* ReadFile */:
+            return this.readFile(params);
+          case "createFile" /* CreateFile */:
+            return this.createFile(params);
+          case "updateFile" /* UpdateFile */:
+            return this.updateFile(params);
+          case "deleteFile" /* DeleteFile */:
+            return this.deleteFile(params);
+          case "createBranch" /* CreateBranch */:
+            return this.createBranch(params);
+          case "listBranches" /* ListBranches */:
+            return this.listBranches(params);
+          case "listCommits" /* ListCommits */:
+            return this.listCommits(params);
+          case "createCommit" /* CreateCommit */:
+            return this.createCommit(params);
+          case "getUser" /* GetUser */:
+            return this.getUser(params);
+          case "listOrganizations" /* ListOrganizations */:
+            return this.listOrganizations(params);
+          default:
+            throw new Error(`Unsupported GitHub action: ${String(action)}`);
+        }
+      }
+    };
+    GitHubAdapterFactory = class {
+      static async create(config2 = {}) {
+        const detection = await GitHubRuntimeDetector.detect(config2);
+        const runtimeConfig = {
+          ...config2,
+          runtime: detection.runtime
+        };
+        if (detection.runtime === "local") {
+          const { GhCliClient: GhCliClient2 } = await Promise.resolve().then(() => (init_local_runtime(), local_runtime_exports));
+          return new GhCliClient2(runtimeConfig);
+        }
+        const { NangoClient: NangoClient2 } = await Promise.resolve().then(() => (init_cloud_runtime(), cloud_runtime_exports));
+        return new NangoClient2(runtimeConfig);
+      }
+      static detect(config2 = {}) {
+        return GitHubRuntimeDetector.detect(config2);
+      }
+      static detectRuntime(config2 = {}) {
+        return GitHubRuntimeDetector.detectRuntime(config2);
+      }
+      static testRuntime(runtime, config2 = {}) {
+        return GitHubRuntimeDetector.testRuntime(runtime, config2);
+      }
+    };
+    GitHubClientFactory = GitHubAdapterFactory;
+  }
+});
+
 // node_modules/compare-versions/lib/umd/index.js
 var require_umd = __commonJS({
   "node_modules/compare-versions/lib/umd/index.js"(exports2, module2) {
@@ -18856,7 +20644,7 @@ var require_umd = __commonJS({
 });
 
 // packages/memory/dist/types.js
-var init_types = __esm({
+var init_types2 = __esm({
   "packages/memory/dist/types.js"() {
     "use strict";
   }
@@ -20180,7 +21968,7 @@ __export(dist_exports2, {
 var init_dist2 = __esm({
   "packages/memory/dist/index.js"() {
     "use strict";
-    init_types();
+    init_types2();
     init_adapters();
     init_factory();
     init_service();
@@ -20223,6 +22011,7 @@ __export(index_exports, {
   ERROR_SEARCH_HINT: () => ERROR_SEARCH_HINT,
   GEMINI_MODEL_OPTIONS: () => GEMINI_MODEL_OPTIONS,
   GeminiModels: () => GeminiModels,
+  GitHubClient: () => GitHubClient,
   HARNESS_VALUES: () => HARNESS_VALUES,
   HOOK_ABI_VERSION: () => HOOK_ABI_VERSION,
   HookEmitter: () => HookEmitter,
@@ -20286,6 +22075,7 @@ __export(index_exports, {
   createConsensusEngine: () => createConsensusEngine,
   createContextCompactor: () => createContextCompactor,
   createDefaultEventLogger: () => createDefaultEventLogger,
+  createGitHubStep: () => createGitHubStep,
   createLogger: () => createLogger,
   createMemoryAdapter: () => createMemoryAdapter,
   createMemoryHooks: () => createMemoryHooks,
@@ -20345,6 +22135,7 @@ __export(index_exports, {
   getSupportedPlatforms: () => getSupportedPlatforms,
   getSupportedReasoningEfforts: () => getSupportedReasoningEfforts,
   getTrajectoryHooks: () => getTrajectoryHooks,
+  github: () => github_exports,
   handleResponse: () => handleResponse2,
   hasRelayPtyBinary: () => hasRelayPtyBinary,
   hasUnreadMessages: () => hasUnreadMessages,
@@ -20956,13 +22747,21 @@ var AgentRelayClient = class _AgentRelayClient {
       requestTimeoutMs: options?.requestTimeoutMs
     });
     client.child = child;
+    const brokerExited = new Promise((_2, reject) => {
+      child.once("exit", (code) => {
+        reject(new Error(formatBrokerStartupError(`Broker process exited with code ${code} during initial handshake`, child, { binaryPath, args, cwd, stdoutLines, stderrLines })));
+      });
+    });
+    brokerExited.catch(() => {
+    });
     let session;
     for (let attempt = 0; attempt < 10; attempt++) {
       try {
-        session = await client.getSession();
+        session = await Promise.race([client.getSession(), brokerExited]);
         break;
       } catch (err) {
-        const is503 = err instanceof Error && (err.message.includes("503") || err.message.includes("Service Unavailable"));
+        const message = err instanceof Error ? err.message : String(err);
+        const is503 = message.includes("503") || message.includes("Service Unavailable");
         if (!is503 || attempt >= 9)
           throw err;
         await new Promise((resolve4) => setTimeout(resolve4, 1e3));
@@ -21817,15 +23616,15 @@ var makeIssue = (params) => {
       message: issueData.message
     };
   }
-  let errorMessage = "";
+  let errorMessage4 = "";
   const maps = errorMaps.filter((m2) => !!m2).slice().reverse();
   for (const map2 of maps) {
-    errorMessage = map2(fullIssue, { data, defaultError: errorMessage }).message;
+    errorMessage4 = map2(fullIssue, { data, defaultError: errorMessage4 }).message;
   }
   return {
     ...issueData,
     path: fullPath,
-    message: errorMessage
+    message: errorMessage4
   };
 };
 var EMPTY_PATH = [];
@@ -25423,19 +27222,19 @@ var getRefs = (options) => {
 };
 
 // node_modules/zod-to-json-schema/dist/esm/errorMessages.js
-function addErrorMessage(res, key, errorMessage, refs) {
+function addErrorMessage(res, key, errorMessage4, refs) {
   if (!refs?.errorMessages)
     return;
-  if (errorMessage) {
+  if (errorMessage4) {
     res.errorMessage = {
       ...res.errorMessage,
-      [key]: errorMessage
+      [key]: errorMessage4
     };
   }
 }
-function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+function setResponseValueAndErrors(res, key, value, errorMessage4, refs) {
   res[key] = value;
-  addErrorMessage(res, key, errorMessage, refs);
+  addErrorMessage(res, key, errorMessage4, refs);
 }
 
 // node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
@@ -43422,11 +45221,11 @@ var WsClient = class {
     this.reconnectAttempt += 1;
     const reconnectingEvent = { type: "reconnecting", attempt: this.reconnectAttempt };
     this.emit("reconnecting", reconnectingEvent);
-    const delay3 = this.computeReconnectDelayMs(this.reconnectAttempt);
+    const delay4 = this.computeReconnectDelayMs(this.reconnectAttempt);
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.connect();
-    }, delay3);
+    }, delay4);
   }
 };
 
@@ -53941,12 +55740,12 @@ function isUtf8(raw) {
   }
 }
 function buildSeedFilePayload(filePath, rootDir) {
-  const relative2 = import_node_path22.default.relative(rootDir, filePath).split(import_node_path22.default.sep).join("/");
+  const relative3 = import_node_path22.default.relative(rootDir, filePath).split(import_node_path22.default.sep).join("/");
   const raw = import_node_fs15.default.readFileSync(filePath);
   if (isUtf8(raw)) {
-    return { path: `/${relative2}`, content: raw.toString("utf8"), encoding: "utf-8" };
+    return { path: `/${relative3}`, content: raw.toString("utf8"), encoding: "utf-8" };
   }
-  return { path: `/${relative2}`, content: raw.toString("base64"), encoding: "base64" };
+  return { path: `/${relative3}`, content: raw.toString("base64"), encoding: "base64" };
 }
 function collectSeedPaths(rootDir, currentRelative, excludeDirs, output) {
   const absoluteDir = import_node_path22.default.join(rootDir, currentRelative);
@@ -56767,7 +58566,7 @@ function delay(ms2) {
 // packages/sdk/dist/workflows/trajectory.js
 var import_node_path28 = require("node:path");
 
-// node_modules/agent-trajectories/dist/chunk-27AQPWHK.js
+// node_modules/agent-trajectories/dist/chunk-WMJRBQB4.js
 var import_module = require("module");
 var import_crypto = require("crypto");
 var import_crypto2 = require("crypto");
@@ -57322,6 +59121,20 @@ function expandPath(path25) {
   }
   return path25;
 }
+function describeReadFailure(reason, error51) {
+  if (reason === "schema_violation" && error51 && typeof error51 === "object" && "issues" in error51) {
+    const issues = error51.issues ?? [];
+    if (issues.length > 0) {
+      const first = issues[0];
+      const where = first.path.length > 0 ? first.path.join(".") : "root";
+      const extra = issues.length > 1 ? ` (+${issues.length - 1} more)` : "";
+      return `${where}: ${first.message}${extra}`;
+    }
+    return "schema validation failed";
+  }
+  if (error51 instanceof Error) return error51.message;
+  return String(error51);
+}
 var indexLocks = /* @__PURE__ */ new Map();
 function withIndexLock(path25, task) {
   const prev = indexLocks.get(path25) ?? Promise.resolve();
@@ -57338,6 +59151,7 @@ var FileStorage = class {
   activeDir;
   completedDir;
   indexPath;
+  lastReconcileSummary;
   constructor(baseDir) {
     this.baseDir = baseDir ?? process.cwd();
     const dataDir = process.env.TRAJECTORIES_DATA_DIR;
@@ -57387,7 +59201,8 @@ var FileStorage = class {
       alreadyIndexed: 0,
       skippedMalformedJson: 0,
       skippedSchemaViolation: 0,
-      skippedIoError: 0
+      skippedIoError: 0,
+      failures: []
     };
     await withIndexLock(this.indexPath, async () => {
       const index = await this.loadIndex();
@@ -57414,6 +59229,11 @@ var FileStorage = class {
           } else {
             summary.skippedIoError += 1;
           }
+          summary.failures.push({
+            path: result.path,
+            reason: result.reason,
+            message: describeReadFailure(result.reason, result.error)
+          });
           continue;
         }
         const trajectory2 = result.trajectory;
@@ -57448,8 +59268,74 @@ var FileStorage = class {
       }
       console.warn(`[trajectories] ${parts.join(", ")}`);
     }
+    this.lastReconcileSummary = summary;
     return summary;
   }
+  /**
+   * Returns the most recent reconcile summary, if any. Lets the CLI
+   * inspect the failures collected during `initialize()` without having
+   * to re-walk the directory tree (and re-emit the warn line).
+   */
+  getLastReconcileSummary() {
+    return this.lastReconcileSummary;
+  }
+  /**
+   * Move trajectory files that fail to load into `.trajectories/invalid/`
+   * so reconcile no longer scans them. Only quarantines parse and schema
+   * failures — transient io_error failures are left in place because the
+   * file may load fine on the next attempt.
+   *
+   * Returns the list of files that were moved (with their original paths
+   * and the destination directory) so the caller can report what changed.
+   */
+  async quarantineInvalid() {
+    const summary = await this.reconcileIndex();
+    const targetDir = (0, import_path4.join)(this.trajectoriesDir, "invalid");
+    const candidates = summary.failures.filter((f2) => f2.reason !== "io_error");
+    if (candidates.length === 0) {
+      return { moved: [], targetDir };
+    }
+    await (0, import_promises7.mkdir)(targetDir, { recursive: true });
+    const moved = [];
+    for (const failure of candidates) {
+      const dest = await this.resolveQuarantineDest(failure.path, targetDir);
+      try {
+        await (0, import_promises7.mkdir)((0, import_path4.dirname)(dest), { recursive: true });
+        await (0, import_promises7.rename)(failure.path, dest);
+        moved.push(failure);
+      } catch (error51) {
+        console.warn(
+          `[trajectories] failed to quarantine ${failure.path}: ${error51 instanceof Error ? error51.message : String(error51)}`
+        );
+      }
+    }
+    return { moved, targetDir };
+  }
+  /**
+   * Pick a destination path under `targetDir` for a quarantined file.
+   *
+   * Preserves the file's relative location under the trajectories root
+   * (e.g. `completed/2026-04/foo.json` → `invalid/completed/2026-04/foo.json`)
+   * so two invalid files that share a basename across `active/` and
+   * `completed/` don't collapse onto each other and silently overwrite.
+   *
+   * Falls back to a numeric-suffix scheme for paths that live outside
+   * the trajectories directory or that, after relative resolution, would
+   * still collide with something already quarantined.
+   */
+  async resolveQuarantineDest(sourcePath, targetDir) {
+    const rel = (0, import_path4.relative)(this.trajectoriesDir, sourcePath);
+    const safeRel = rel && !rel.startsWith("..") && !(0, import_path4.isAbsolute)(rel) ? rel : (0, import_path4.basename)(sourcePath);
+    let dest = (0, import_path4.join)(targetDir, safeRel);
+    if (!(0, import_fs5.existsSync)(dest)) return dest;
+    const ext = safeRel.endsWith(".json") ? ".json" : "";
+    const stem = ext ? safeRel.slice(0, -ext.length) : safeRel;
+    for (let i = 1; i < 1e3; i += 1) {
+      dest = (0, import_path4.join)(targetDir, `${stem}.${i}${ext}`);
+      if (!(0, import_fs5.existsSync)(dest)) return dest;
+    }
+    return dest;
+  }
   /**
    * Recursively collect all .json file paths under `dir` into `out`.
    * Silently treats a missing directory as empty.
@@ -58765,14 +60651,14 @@ var WorkflowRunner = class _WorkflowRunner {
     if (!mount) {
       return cwd;
     }
-    const relative2 = import_node_path29.default.relative(this.cwd, cwd);
-    if (relative2 === "") {
+    const relative3 = import_node_path29.default.relative(this.cwd, cwd);
+    if (relative3 === "") {
       return mount.mountPoint;
     }
-    if (relative2 === ".." || relative2.startsWith(`..${import_node_path29.default.sep}`)) {
+    if (relative3 === ".." || relative3.startsWith(`..${import_node_path29.default.sep}`)) {
       return cwd;
     }
-    return import_node_path29.default.resolve(mount.mountPoint, relative2);
+    return import_node_path29.default.resolve(mount.mountPoint, relative3);
   }
   resolveExecutionCwd(step, agentDef) {
     const cwd = this.resolveEffectiveCwd(step, agentDef);
@@ -59147,10 +61033,10 @@ ${next}` : next;
     return changes.sort((a, b2) => a.path.localeCompare(b2.path));
   }
   normalizeEvidencePath(filePath) {
-    const relative2 = import_node_path29.default.relative(this.cwd, filePath);
-    if (!relative2 || relative2 === "")
+    const relative3 = import_node_path29.default.relative(this.cwd, filePath);
+    if (!relative3 || relative3 === "")
       return import_node_path29.default.basename(filePath);
-    return relative2.startsWith("..") ? filePath : relative2;
+    return relative3.startsWith("..") ? filePath : relative3;
   }
   buildStepCompletionDecision(stepName, completionReason) {
     let reason;
@@ -60730,7 +62616,7 @@ ${trimmedOutput.slice(0, 200)}`);
   }
   async executeStep(step, state, stepStates, agentMap, errorHandling, runId, lifecycle) {
     if (this.isDeterministicStep(step)) {
-      return this.executeDeterministicStep(step, state, stepStates, runId, errorHandling, lifecycle);
+      return this.executeDeterministicStep(step, state, stepStates, agentMap, runId, errorHandling, lifecycle);
     }
     if (this.isWorktreeStep(step)) {
       return this.executeWorktreeStep(step, state, stepStates, runId, lifecycle);
@@ -60744,13 +62630,18 @@ ${trimmedOutput.slice(0, 200)}`);
    * Execute a deterministic step (shell command).
    * Fast, reliable, $0 LLM cost.
    */
-  async executeDeterministicStep(step, state, stepStates, runId, errorHandling, lifecycle) {
-    const maxRetries = step.retries ?? errorHandling?.maxRetries ?? 0;
+  async executeDeterministicStep(step, state, stepStates, agentMap, runId, errorHandling, lifecycle) {
+    const repairRetries = errorHandling?.strategy === "retry" ? errorHandling.repairRetries ?? 0 : 0;
+    const repairAgent = repairRetries > 0 ? this.resolveDeterministicRepairAgent(step, stepStates, agentMap, errorHandling) : void 0;
+    const maxRetries = step.retries ?? errorHandling?.maxRetries ?? (repairAgent ? repairRetries : 0);
     const retryDelay = errorHandling?.retryDelayMs ?? 1e3;
     let lastError = "Unknown error";
     let lastCompletionReason;
     let lastExitCode;
     let lastExitSignal;
+    let lastResolvedCommand = step.command ?? "";
+    let lastStepCwd = this.cwd;
+    let lastCommandOutput = "";
     const result = await lifecycle.monitorStep(step, state, {
       maxRetries,
       retryDelayMs: retryDelay,
@@ -60763,6 +62654,20 @@ ${trimmedOutput.slice(0, 200)}`);
           detail: `Retrying attempt ${attempt + 1}/${total + 1}`,
           raw: { attempt, maxRetries: total }
         });
+        if (repairAgent) {
+          await this.runDeterministicRepairAgent({
+            step,
+            agentDef: repairAgent,
+            attempt,
+            maxRetries: total,
+            command: lastResolvedCommand,
+            cwd: lastStepCwd,
+            error: lastError,
+            output: lastCommandOutput,
+            exitCode: lastExitCode,
+            exitSignal: lastExitSignal
+          });
+        }
       },
       execute: async () => {
         const stepOutputContext = this.buildStepOutputContext(stepStates, runId);
@@ -60774,12 +62679,15 @@ ${trimmedOutput.slice(0, 200)}`);
           return value !== void 0 ? String(value) : _match;
         });
         const stepCwd = this.resolveEffectiveCwd(step);
+        lastResolvedCommand = resolvedCommand;
+        lastStepCwd = stepCwd;
         this.beginStepEvidence(step.name, [stepCwd], state.row.startedAt);
         this.log(`[${step.name}] Running: ${resolvedCommand.slice(0, 200)}${resolvedCommand.length > 200 ? "..." : ""}`);
         if (this.executor?.executeDeterministicStep) {
           const executorResult = await this.executor.executeDeterministicStep(step, resolvedCommand, stepCwd);
           lastExitCode = executorResult.exitCode;
           lastExitSignal = void 0;
+          lastCommandOutput = executorResult.output;
           const failOnError = step.failOnError !== false;
           if (failOnError && executorResult.exitCode !== 0) {
             this.log(`[${step.name}] Command failed (exit code ${executorResult.exitCode})`);
@@ -60851,6 +62759,7 @@ ${executorResult.output}`);
             commandStderr = stderr;
             lastExitCode = code ?? void 0;
             lastExitSignal = signal ?? void 0;
+            lastCommandOutput = [stdout, stderr].filter(Boolean).join("\n");
             const failOnError = step.failOnError !== false;
             if (failOnError && code !== 0 && code !== null) {
               this.log(`[${step.name}] Command failed (exit code ${code})`);
@@ -60882,6 +62791,7 @@ ${stderr}`);
           combined: [commandStdout || output, commandStderr].filter(Boolean).join("\n")
         }, { exitCode: lastExitCode, exitSignal: lastExitSignal });
         const verificationResult = step.verification ? this.runVerification(step.verification, output, step.name) : void 0;
+        lastCommandOutput = [commandStdout || output, commandStderr].filter(Boolean).join("\n");
         return {
           output,
           completionReason: verificationResult?.completionReason
@@ -60914,6 +62824,131 @@ ${stderr}`);
       throw new Error(`Step "${step.name}" failed: ${result.error ?? "Unknown error"}`);
     }
   }
+  resolveDeterministicRepairAgent(step, stepStates, agentMap, errorHandling) {
+    const explicitName = errorHandling?.repairAgent?.trim();
+    if (explicitName) {
+      const explicitAgent = agentMap.get(explicitName);
+      if (explicitAgent)
+        return _WorkflowRunner.resolveAgentDef(explicitAgent);
+      this.log(`[${step.name}] repairAgent "${explicitName}" not found; falling back to workflow agents`);
+    }
+    if (step.agent) {
+      const stepAgent = agentMap.get(step.agent);
+      if (stepAgent)
+        return _WorkflowRunner.resolveAgentDef(stepAgent);
+    }
+    for (const dependency of [...step.dependsOn ?? []].reverse()) {
+      const dependencyAgent = stepStates.get(dependency)?.row.agentName;
+      if (!dependencyAgent)
+        continue;
+      const agent = agentMap.get(dependencyAgent);
+      if (agent)
+        return _WorkflowRunner.resolveAgentDef(agent);
+    }
+    const candidates = [...agentMap.values()].map((agent) => _WorkflowRunner.resolveAgentDef(agent));
+    candidates.sort((a, b2) => this.scoreRepairAgent(b2) - this.scoreRepairAgent(a));
+    return candidates[0];
+  }
+  scoreRepairAgent(agent) {
+    const text = `${agent.name} ${agent.role ?? ""} ${agent.preset ?? ""}`.toLowerCase();
+    let score = 0;
+    if (/\b(repair|fix|implement|implementation|engineer|developer|coder|worker|owner|lead|coordinator)\b/.test(text)) {
+      score += 10;
+    }
+    if (agent.interactive === false || ["worker", "analyst"].includes(agent.preset ?? "")) {
+      score += 2;
+    }
+    if (/\b(review|reviewer|audit|security|analyst)\b/.test(text)) {
+      score -= 4;
+    }
+    if (agent.permissions?.access === "readonly") {
+      score -= 20;
+    }
+    return score;
+  }
+  async runDeterministicRepairAgent(context) {
+    const repairAgent = {
+      ...context.agentDef,
+      interactive: false
+    };
+    const repairPrompt = this.buildDeterministicRepairPrompt(context);
+    const repairStep = {
+      name: `${context.step.name}-repair-${context.attempt}`,
+      type: "agent",
+      agent: repairAgent.name,
+      task: repairPrompt,
+      cwd: context.cwd,
+      workdir: void 0,
+      retries: 0
+    };
+    const timeoutMs = repairAgent.constraints?.timeoutMs ?? context.step.timeoutMs ?? this.currentConfig?.swarm?.timeoutMs;
+    this.log(`[${context.step.name}] Deterministic gate failed; asking "${repairAgent.name}" to repair before retry ${context.attempt + 1}/${context.maxRetries + 1}`);
+    this.postToChannel(`**[${context.step.name}]** Deterministic gate failed; assigning repair to \`${repairAgent.name}\``);
+    this.recordStepToolSideEffect(context.step.name, {
+      type: "custom",
+      detail: `Assigned deterministic gate repair to ${repairAgent.name}`,
+      raw: {
+        repairAgent: repairAgent.name,
+        attempt: context.attempt,
+        maxRetries: context.maxRetries,
+        exitCode: context.exitCode,
+        exitSignal: context.exitSignal
+      }
+    });
+    try {
+      this.ensureBudgetAllowsSpawn(context.step.name, repairAgent.name);
+      let repairOutput;
+      if (this.executor) {
+        repairOutput = await this.executor.executeAgentStep(repairStep, repairAgent, repairPrompt, timeoutMs);
+      } else if (repairAgent.cli === "api") {
+        repairOutput = await executeApiStep(repairAgent.constraints?.model ?? "claude-sonnet-4-20250514", repairPrompt, {
+          envSecrets: this.envSecrets,
+          skills: repairAgent.skills,
+          defaultMaxTokens: repairAgent.constraints?.maxTokens
+        });
+      } else {
+        const result = await this.execNonInteractive(repairAgent, repairStep, timeoutMs);
+        repairOutput = result.output;
+      }
+      this.recordStepToolSideEffect(context.step.name, {
+        type: "custom",
+        detail: `Repair agent ${repairAgent.name} completed before deterministic retry`,
+        raw: { repairAgent: repairAgent.name, output: repairOutput.slice(0, 1e3) }
+      });
+    } catch (error51) {
+      if (error51 instanceof BudgetExceededError || this.abortController?.signal.aborted) {
+        throw error51;
+      }
+      const message = error51 instanceof Error ? error51.message : String(error51);
+      this.log(`[${context.step.name}] Repair agent "${repairAgent.name}" failed: ${message}`);
+      this.postToChannel(`**[${context.step.name}]** Repair agent \`${repairAgent.name}\` failed; retrying gate anyway`);
+      this.recordStepToolSideEffect(context.step.name, {
+        type: "custom",
+        detail: `Repair agent ${repairAgent.name} failed before deterministic retry: ${message}`,
+        raw: { repairAgent: repairAgent.name, error: message }
+      });
+    }
+  }
+  buildDeterministicRepairPrompt(context) {
+    const output = context.output.trim();
+    const clippedOutput = output.length > 4e3 ? output.slice(-4e3) : output;
+    return `A deterministic workflow gate failed after an agent/team step. Fix the repository or workflow state so the same gate passes on the next retry.
+
+Step: ${context.step.name}
+Working directory: ${context.cwd}
+Command:
+${context.command}
+
+Failure:
+${context.error}
+Exit code: ${context.exitCode ?? "unknown"}
+Exit signal: ${context.exitSignal ?? "none"}
+
+Command output:
+${clippedOutput || "(no output captured)"}
+
+Repair only what is needed for this gate to pass. Preserve unrelated user changes. After making the fix, report the files changed and the reason the gate should pass.`;
+  }
   /**
    * Execute a worktree step (git worktree setup).
    * Fast, reliable, $0 LLM cost.
@@ -60931,7 +62966,7 @@ ${stderr}`);
         const branch = this.interpolateStepTask(step.branch ?? "", stepOutputContext);
         const baseBranch = step.baseBranch ? this.interpolateStepTask(step.baseBranch, stepOutputContext) : "HEAD";
         const worktreePath = step.path ? this.interpolateStepTask(step.path, stepOutputContext) : import_node_path29.default.join(".worktrees", step.name);
-        const createBranch = step.createBranch !== false;
+        const createBranch2 = step.createBranch !== false;
         const stepCwd = this.resolveStepWorkdir(step) ?? this.cwd;
         this.beginStepEvidence(step.name, [stepCwd], state.row.startedAt);
         if (!branch) {
@@ -60954,7 +62989,7 @@ ${stderr}`);
         let worktreeArgs;
         if (branchExists) {
           worktreeArgs = ["worktree", "add", absoluteWorktreePath, branch];
-        } else if (createBranch) {
+        } else if (createBranch2) {
           worktreeArgs = ["worktree", "add", "-b", branch, absoluteWorktreePath, baseBranch];
         } else {
           throw new Error(`Branch "${branch}" does not exist and createBranch is false`);
@@ -61032,7 +63067,7 @@ ${stderr}`);
           combined: [commandStdout || output, commandStderr].filter(Boolean).join("\n")
         }, { exitCode: lastExitCode, exitSignal: lastExitSignal });
         worktreeBranch = branch;
-        createdBranch = !branchExists && createBranch;
+        createdBranch = !branchExists && createBranch2;
         return { output };
       },
       toCompletionResult: ({ output }, attempt) => ({
@@ -61151,18 +63186,18 @@ ${stderr}`);
         await this.persistStepOutput(runId, step.name, output);
         this.emit({ type: "step:completed", runId, stepName: step.name, output });
       } catch (apiError) {
-        const errorMessage = apiError instanceof Error ? apiError.message : String(apiError);
+        const errorMessage4 = apiError instanceof Error ? apiError.message : String(apiError);
         state.row.status = "failed";
-        state.row.error = errorMessage;
+        state.row.error = errorMessage4;
         state.row.completedAt = (/* @__PURE__ */ new Date()).toISOString();
         await this.db.updateStep(state.row.id, {
           status: "failed",
-          error: errorMessage,
+          error: errorMessage4,
           completedAt: state.row.completedAt,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
-        this.emit({ type: "step:failed", runId, stepName: step.name, error: errorMessage });
-        this.postToChannel(`**[${step.name}]** Failed (api): ${errorMessage}`);
+        this.emit({ type: "step:failed", runId, stepName: step.name, error: errorMessage4 });
+        this.postToChannel(`**[${step.name}]** Failed (api): ${errorMessage4}`);
         throw apiError;
       }
       return;
@@ -62991,15 +65026,15 @@ DO NOT:
       throw error51;
     }
   }
-  updateCustomVerificationFailure(stepName, check2, errorMessage) {
-    if (check2.type !== "custom" || !check2.value || !errorMessage) {
+  updateCustomVerificationFailure(stepName, check2, errorMessage4) {
+    if (check2.type !== "custom" || !check2.value || !errorMessage4) {
       this.lastCustomVerificationFailure.delete(stepName);
       return;
     }
     const marker = `custom check "${check2.value}" failed
 `;
-    const markerIndex = errorMessage.indexOf(marker);
-    const output = markerIndex === -1 ? errorMessage.trim() : errorMessage.slice(markerIndex + marker.length).trim();
+    const markerIndex = errorMessage4.indexOf(marker);
+    const output = markerIndex === -1 ? errorMessage4.trim() : errorMessage4.slice(markerIndex + marker.length).trim();
     this.lastCustomVerificationFailure.set(stepName, {
       command: check2.value,
       output
@@ -64271,6 +66306,10 @@ var WorkflowBuilder = class {
       this._errorHandling.retryDelayMs = options.retryDelayMs;
     if (options?.notifyChannel !== void 0)
       this._errorHandling.notifyChannel = options.notifyChannel;
+    if (options?.repairAgent !== void 0)
+      this._errorHandling.repairAgent = options.repairAgent;
+    if (options?.repairRetries !== void 0)
+      this._errorHandling.repairRetries = options.repairRetries;
     return this;
   }
   validateBuilderState() {
@@ -66037,6 +68076,751 @@ Run ID: ${runId}`;
   throw new Error(`Unsupported file type: ${ext}. Use .yaml, .yml, .ts, or .py`);
 }
 
+// packages/sdk/dist/github.js
+var github_exports = {};
+__export(github_exports, {
+  BaseGitHubAdapter: () => BaseGitHubAdapter,
+  DEFAULT_GH_PATH: () => DEFAULT_GH_PATH,
+  DEFAULT_MAX_RETRIES: () => DEFAULT_MAX_RETRIES,
+  DEFAULT_NANGO_BASE_URL: () => DEFAULT_NANGO_BASE_URL,
+  DEFAULT_NANGO_PROVIDER_CONFIG_KEY: () => DEFAULT_NANGO_PROVIDER_CONFIG_KEY,
+  DEFAULT_RELAY_CLOUD_GITHUB_PROXY_ENDPOINT: () => DEFAULT_RELAY_CLOUD_GITHUB_PROXY_ENDPOINT,
+  DEFAULT_TIMEOUT: () => DEFAULT_TIMEOUT,
+  DEFAULT_USER_AGENT: () => DEFAULT_USER_AGENT,
+  GITHUB_ACTIONS: () => GITHUB_ACTIONS,
+  GhCliClient: () => GhCliClient,
+  GhCliError: () => GhCliError,
+  GitHubAction: () => GitHubAction,
+  GitHubAdapterFactory: () => GitHubAdapterFactory,
+  GitHubApiError: () => GitHubApiError,
+  GitHubClient: () => GitHubClient,
+  GitHubClientFactory: () => GitHubClientFactory,
+  GitHubClientInterface: () => GitHubClientInterface,
+  GitHubRuntimeDetector: () => GitHubRuntimeDetector,
+  GitHubStepExecutor: () => GitHubStepExecutor,
+  NangoClient: () => NangoClient,
+  createBranch: () => createBranch,
+  createCommit: () => createCommit,
+  createFile: () => createFile,
+  createGitHubAdapter: () => createGitHubAdapter,
+  createGitHubStep: () => createGitHubStep,
+  createIssue: () => createIssue,
+  createPR: () => createPR,
+  deleteFile: () => deleteFile,
+  detectGitHubRuntime: () => detectGitHubRuntime,
+  getBranch: () => getBranch,
+  getPR: () => getPR,
+  getRepo: () => getRepo,
+  getUser: () => getUser,
+  githubStepConfigFromWorkflowStep: () => githubStepConfigFromWorkflowStep,
+  listBranches: () => listBranches,
+  listCommits: () => listCommits,
+  listFiles: () => listFiles,
+  listIssues: () => listIssues,
+  listOrganizations: () => listOrganizations,
+  listPRs: () => listPRs,
+  listRepos: () => listRepos,
+  mapBranch: () => mapBranch,
+  mapCommit: () => mapCommit,
+  mapFile: () => mapFile,
+  mapIssue: () => mapIssue,
+  mapOrganization: () => mapOrganization,
+  mapPR: () => mapPR,
+  mapRepo: () => mapRepo,
+  mapUser: () => mapUser,
+  mergePR: () => mergePR,
+  normalizeGitHubRuntimeConfig: () => normalizeGitHubRuntimeConfig,
+  readFile: () => readFile3,
+  updateFile: () => updateFile,
+  updateIssue: () => updateIssue,
+  updatePR: () => updatePR
+});
+
+// packages/github-primitive/src/index.ts
+init_constants();
+init_types();
+init_adapter();
+init_local_runtime();
+init_cloud_runtime();
+
+// packages/github-primitive/src/client.ts
+init_adapter();
+var GitHubClient = class _GitHubClient {
+  adapterPromise;
+  constructor(config2 = {}) {
+    this.adapterPromise = GitHubAdapterFactory.create(config2);
+  }
+  /**
+   * Create a GitHub client and eagerly resolve runtime detection.
+   */
+  static async create(config2 = {}) {
+    const client = new _GitHubClient(config2);
+    await client.getAdapter();
+    return client;
+  }
+  /**
+   * Inspect runtime availability without creating a client.
+   */
+  static detect(config2 = {}) {
+    return GitHubAdapterFactory.detect(config2);
+  }
+  /**
+   * Detect the runtime that would be selected for the supplied configuration.
+   */
+  static detectRuntime(config2 = {}) {
+    return GitHubAdapterFactory.detectRuntime(config2);
+  }
+  /**
+   * Return the selected low-level adapter.
+   */
+  getAdapter() {
+    return this.adapterPromise;
+  }
+  /**
+   * Return the runtime selected by auto-detection or explicit configuration.
+   */
+  async getRuntime() {
+    return (await this.getAdapter()).getRuntime();
+  }
+  /**
+   * Check whether the selected runtime is authenticated.
+   */
+  async isAuthenticated() {
+    return (await this.getAdapter()).isAuthenticated();
+  }
+  /**
+   * Fetch the authenticated GitHub user for the selected runtime.
+   */
+  async getCurrentUser() {
+    return (await this.getAdapter()).getCurrentUser();
+  }
+  /**
+   * Execute a raw GitHub API request through the selected adapter.
+   */
+  async request(method, path25, options) {
+    return (await this.getAdapter()).request(method, path25, options);
+  }
+  /**
+   * Execute any registered GitHub primitive action by action name.
+   */
+  async executeAction(action, params) {
+    return (await this.getAdapter()).executeAction(action, params);
+  }
+  /**
+   * List repositories visible to the authenticated GitHub identity.
+   */
+  async listRepos(options = {}) {
+    return (await this.getAdapter()).listRepositories(options);
+  }
+  /**
+   * Fetch a repository by owner and name.
+   */
+  async getRepo(owner, repo) {
+    return (await this.getAdapter()).getRepository({ owner, repo });
+  }
+  /**
+   * List issues for a repository.
+   */
+  async listIssues(owner, repo, options = {}) {
+    return (await this.getAdapter()).listIssues({ owner, repo, ...options });
+  }
+  /**
+   * Create an issue in a repository.
+   */
+  async createIssue(owner, repo, title, body, options = {}) {
+    return (await this.getAdapter()).createIssue({ owner, repo, title, body, ...options });
+  }
+  /**
+   * Update an existing issue by issue number.
+   */
+  async updateIssue(owner, repo, number4, updates) {
+    return (await this.getAdapter()).updateIssue({
+      owner,
+      repo,
+      issueNumber: number4,
+      ...updates
+    });
+  }
+  /**
+   * Close an issue by issue number.
+   */
+  async closeIssue(owner, repo, number4) {
+    return (await this.getAdapter()).closeIssue({ owner, repo, issueNumber: number4 });
+  }
+  /**
+   * List pull requests for a repository.
+   */
+  async listPRs(owner, repo, options = {}) {
+    return (await this.getAdapter()).listPullRequests({ owner, repo, ...options });
+  }
+  /**
+   * Fetch a pull request by pull request number.
+   */
+  async getPR(owner, repo, number4) {
+    return (await this.getAdapter()).getPullRequest({ owner, repo, pullNumber: number4 });
+  }
+  /**
+   * Create a pull request.
+   */
+  async createPR(owner, repo, title, body, base, head, options = {}) {
+    return (await this.getAdapter()).createPullRequest({
+      owner,
+      repo,
+      title,
+      body,
+      base,
+      head,
+      ...options
+    });
+  }
+  /**
+   * Update an existing pull request by pull request number.
+   */
+  async updatePR(owner, repo, number4, updates) {
+    return (await this.getAdapter()).updatePullRequest({
+      owner,
+      repo,
+      pullNumber: number4,
+      ...updates
+    });
+  }
+  /**
+   * Merge a pull request and return the refreshed pull request.
+   */
+  async mergePR(owner, repo, number4, options = {}) {
+    return (await this.getAdapter()).mergePullRequest({
+      owner,
+      repo,
+      pullNumber: number4,
+      ...options
+    });
+  }
+  /**
+   * List files or directories at a repository path.
+   */
+  async listFiles(owner, repo, path25 = "", options = {}) {
+    return (await this.getAdapter()).listFiles({ owner, repo, path: path25, ...options });
+  }
+  /**
+   * Read a repository file and return decoded UTF-8 content.
+   */
+  async readFile(owner, repo, path25, ref) {
+    return (await this.getAdapter()).readFile({ owner, repo, path: path25, ref });
+  }
+  /**
+   * Create a repository file with a commit message.
+   */
+  async createFile(owner, repo, path25, content, message, options = {}) {
+    await (await this.getAdapter()).createFile({
+      owner,
+      repo,
+      path: path25,
+      content,
+      message,
+      ...options
+    });
+  }
+  /**
+   * Update a repository file with a commit message.
+   */
+  async updateFile(owner, repo, path25, content, message, sha, options = {}) {
+    return (await this.getAdapter()).updateFile({
+      owner,
+      repo,
+      path: path25,
+      content,
+      message,
+      sha,
+      ...options
+    });
+  }
+  /**
+   * Delete a repository file with a commit message.
+   */
+  async deleteFile(owner, repo, path25, sha, message, options = {}) {
+    await (await this.getAdapter()).deleteFile({
+      owner,
+      repo,
+      path: path25,
+      sha,
+      message,
+      ...options
+    });
+  }
+  /**
+   * List repository branches.
+   */
+  async listBranches(owner, repo) {
+    return (await this.getAdapter()).listBranches({ owner, repo });
+  }
+  /**
+   * Create a branch from another branch, or from the repository default branch.
+   */
+  async createBranch(owner, repo, branch, options = {}) {
+    await (await this.getAdapter()).createBranch({ owner, repo, branch, ...options });
+  }
+  /**
+   * List repository commits.
+   */
+  async listCommits(owner, repo, options = {}) {
+    return (await this.getAdapter()).listCommits({ owner, repo, ...options });
+  }
+  /**
+   * Create a Git commit object.
+   */
+  async createCommit(owner, repo, message, tree, parents, options = {}) {
+    return (await this.getAdapter()).createCommit({
+      owner,
+      repo,
+      message,
+      tree,
+      parents,
+      ...options
+    });
+  }
+  /**
+   * Fetch the authenticated user, or a public user by username.
+   */
+  async getUser(username) {
+    return (await this.getAdapter()).getUser(username ? { username } : void 0);
+  }
+  /**
+   * List organizations for the authenticated user, or for a public user.
+   */
+  async listOrganizations(username, options = {}) {
+    return (await this.getAdapter()).listOrganizations({ username, ...options });
+  }
+};
+
+// packages/github-primitive/src/workflow-step.ts
+init_types();
+var GITHUB_INTEGRATION = "github";
+var RESERVED_PARAM_KEYS = /* @__PURE__ */ new Set([
+  "action",
+  "config",
+  "githubConfig",
+  "output",
+  "params",
+  "actionParams",
+  "repository",
+  "runtime",
+  "ghPath",
+  "timeout",
+  "retryOnRateLimit",
+  "maxRetries"
+]);
+function createGitHubStep(config2) {
+  validateGitHubStepConfig(config2);
+  const params = {};
+  if (config2.repo !== void 0) {
+    params.repo = repoToString(config2.repo);
+  }
+  if (config2.params !== void 0) {
+    params.params = JSON.stringify(config2.params);
+  }
+  if (config2.config !== void 0) {
+    params.config = JSON.stringify(config2.config);
+  }
+  if (config2.output !== void 0) {
+    params.output = JSON.stringify(config2.output);
+  }
+  const step = {
+    name: config2.name,
+    type: "integration",
+    integration: GITHUB_INTEGRATION,
+    action: config2.action,
+    params
+  };
+  if (config2.dependsOn !== void 0) step.dependsOn = config2.dependsOn;
+  if (config2.timeoutMs !== void 0) step.timeoutMs = config2.timeoutMs;
+  if (config2.retries !== void 0) step.retries = config2.retries;
+  return step;
+}
+var GitHubStepExecutor = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  async executeAgentStep() {
+    throw new Error("GitHubStepExecutor only executes GitHub integration steps.");
+  }
+  async execute(config2, context = {}) {
+    validateGitHubStepConfig(config2);
+    const runtimeConfig = mergeRuntimeConfig(this.options, context.config, config2.config);
+    if (context.workspaceId && !runtimeConfig.relayCloud?.workspaceId) {
+      runtimeConfig.relayCloud = {
+        ...runtimeConfig.relayCloud,
+        workspaceId: context.workspaceId
+      };
+    }
+    const client = context.client ?? new GitHubClient(runtimeConfig);
+    const actionParams = buildActionParams(config2);
+    const result = await client.executeAction(config2.action, actionParams);
+    const runtime = result.metadata?.runtime ?? await safeGetRuntime(client);
+    const output = formatStepOutput2(config2, result, runtime);
+    return {
+      success: result.success,
+      output,
+      result,
+      runtime,
+      error: result.error
+    };
+  }
+  async executeIntegrationStep(step, resolvedParams, context = {}) {
+    if (step.integration !== GITHUB_INTEGRATION) {
+      return {
+        success: false,
+        output: `GitHubStepExecutor only handles "${GITHUB_INTEGRATION}" integration steps`
+      };
+    }
+    try {
+      const config2 = githubStepConfigFromWorkflowStep(step, resolvedParams);
+      const result = await this.execute(config2, context);
+      return {
+        success: result.success,
+        output: result.success ? result.output : result.output || result.error || "GitHub step failed"
+      };
+    } catch (error51) {
+      return {
+        success: false,
+        output: error51 instanceof Error ? error51.message : String(error51)
+      };
+    }
+  }
+};
+function githubStepConfigFromWorkflowStep(step, resolvedParams) {
+  const params = normalizeResolvedParams(resolvedParams);
+  const action = step.action;
+  if (!action) {
+    throw new Error(`GitHub step "${step.name}" requires an action`);
+  }
+  const config2 = readJsonParam(params.config ?? params.githubConfig, "config") ?? runtimeConfigFromParams(params);
+  const output = readJsonParam(params.output, "output") ?? void 0;
+  const repo = readRepositoryParam(params);
+  const actionParams = readActionParams(params);
+  return {
+    name: step.name,
+    dependsOn: step.dependsOn,
+    action,
+    repo,
+    params: actionParams,
+    config: config2,
+    output,
+    timeoutMs: step.timeoutMs,
+    retries: step.retries
+  };
+}
+function validateGitHubStepConfig(config2) {
+  if (!config2.name) {
+    throw new Error("GitHub step requires a non-empty name");
+  }
+  if (!config2.action || typeof config2.action !== "string") {
+    throw new Error(`GitHub step "${config2.name}" requires an action name`);
+  }
+  if (!GITHUB_ACTIONS.includes(config2.action)) {
+    throw new Error(`GitHub step "${config2.name}" uses unsupported action "${config2.action}"`);
+  }
+  if (config2.repo !== void 0) {
+    parseRepositoryRef(config2.repo);
+  }
+  if (config2.params !== void 0 && !isRecord2(config2.params)) {
+    throw new Error(`GitHub step "${config2.name}" params must be an object`);
+  }
+}
+function buildActionParams(config2) {
+  const repo = config2.repo === void 0 ? void 0 : parseRepositoryRef(config2.repo);
+  const params = config2.params ? { ...config2.params } : {};
+  const merged = repo ? { ...repo, ...params } : params;
+  return Object.keys(merged).length === 0 ? void 0 : merged;
+}
+function readActionParams(params) {
+  const serializedParams = params.params ?? params.actionParams;
+  if (serializedParams !== void 0) {
+    const parsed = readJsonParam(serializedParams, "params");
+    if (parsed === void 0) return {};
+    if (!isRecord2(parsed)) {
+      throw new Error("GitHub step params.params must be a JSON object");
+    }
+    return parsed;
+  }
+  const actionParams = {};
+  const repoValue = params.repo;
+  const repoIsRepositoryRef = params.owner === void 0 && typeof repoValue === "string" && repoValue.includes("/");
+  for (const [key, value] of Object.entries(params)) {
+    if (RESERVED_PARAM_KEYS.has(key)) continue;
+    if (key === "repo" && repoIsRepositoryRef) continue;
+    actionParams[key] = value;
+  }
+  return actionParams;
+}
+function readRepositoryParam(params) {
+  const value = params.repository ?? (params.owner === void 0 ? params.repo : void 0);
+  if (value === void 0) return void 0;
+  if (typeof value === "string" || isRecord2(value)) {
+    return parseRepositoryRef(value);
+  }
+  throw new Error("GitHub step repo must be in owner/repo format");
+}
+function runtimeConfigFromParams(params) {
+  const config2 = {};
+  if (typeof params.runtime === "string") {
+    config2.runtime = params.runtime;
+  }
+  if (typeof params.ghPath === "string") {
+    config2.ghPath = params.ghPath;
+  }
+  if (typeof params.timeout === "number") {
+    config2.timeout = params.timeout;
+  }
+  if (typeof params.retryOnRateLimit === "boolean") {
+    config2.retryOnRateLimit = params.retryOnRateLimit;
+  }
+  if (typeof params.maxRetries === "number") {
+    config2.maxRetries = params.maxRetries;
+  }
+  return Object.keys(config2).length === 0 ? void 0 : config2;
+}
+function mergeRuntimeConfig(...configs) {
+  const merged = {};
+  for (const config2 of configs) {
+    if (!config2) continue;
+    const { nango, relayCloud, env, ...flatConfig } = config2;
+    Object.assign(merged, flatConfig);
+    if (nango) {
+      merged.nango = {
+        ...merged.nango,
+        ...nango
+      };
+    }
+    if (relayCloud) {
+      merged.relayCloud = {
+        ...merged.relayCloud,
+        ...relayCloud
+      };
+    }
+    if (env) {
+      merged.env = {
+        ...merged.env,
+        ...env
+      };
+    }
+  }
+  return merged;
+}
+function formatStepOutput2(config2, result, runtime) {
+  const outputConfig = config2.output ?? {};
+  const mode = outputConfig.mode ?? "data";
+  const format2 = outputConfig.format ?? "json";
+  if (mode === "none") {
+    return "";
+  }
+  let projection = buildOutputProjection(mode, result, runtime, outputConfig);
+  if (outputConfig.path) {
+    projection = resolvePath2(projection, outputConfig.path);
+  }
+  if (format2 === "text") {
+    return projectionToText(projection);
+  }
+  return JSON.stringify(projection, void 0, outputConfig.pretty ? 2 : void 0);
+}
+function buildOutputProjection(mode, result, runtime, outputConfig) {
+  if (mode === "raw") {
+    return result.output;
+  }
+  if (mode === "summary") {
+    return withOptionalMetadata(summarizeResult(result, runtime), result, runtime, outputConfig);
+  }
+  if (mode === "result") {
+    const projected = {
+      success: result.success,
+      output: result.output
+    };
+    if (result.data !== void 0) projected.data = result.data;
+    if (result.error !== void 0) projected.error = result.error;
+    return withOptionalMetadata(projected, result, runtime, outputConfig);
+  }
+  const data = result.data ?? (result.output ? result.output : null);
+  return withOptionalMetadata(data, result, runtime, outputConfig);
+}
+function summarizeResult(result, runtime) {
+  if (!result.success) {
+    return {
+      success: false,
+      error: result.error ?? "GitHub action failed",
+      runtime
+    };
+  }
+  const data = result.data;
+  if (Array.isArray(data)) {
+    return {
+      success: true,
+      count: data.length,
+      items: data.slice(0, 10).map(summarizeValue),
+      runtime
+    };
+  }
+  return {
+    success: true,
+    value: summarizeValue(data ?? result.output),
+    runtime
+  };
+}
+function summarizeValue(value) {
+  if (!isRecord2(value)) {
+    return value;
+  }
+  const summary = {};
+  for (const key of [
+    "fullName",
+    "name",
+    "number",
+    "title",
+    "state",
+    "path",
+    "sha",
+    "type",
+    "defaultBranch",
+    "visibility",
+    "private",
+    "createdAt",
+    "updatedAt",
+    "htmlUrl",
+    "url"
+  ]) {
+    if (value[key] !== void 0) {
+      summary[key] = value[key];
+    }
+  }
+  return Object.keys(summary).length > 0 ? summary : value;
+}
+function withOptionalMetadata(value, result, runtime, outputConfig) {
+  if (!outputConfig.includeMetadata && !outputConfig.includeRuntime) {
+    return value;
+  }
+  const metadata = {};
+  if (outputConfig.includeRuntime && runtime !== void 0) metadata.runtime = runtime;
+  if (outputConfig.includeMetadata && result.metadata !== void 0) {
+    Object.assign(metadata, result.metadata);
+  }
+  return { value, metadata };
+}
+function projectionToText(value) {
+  if (typeof value === "string") return value;
+  if (value === null || value === void 0) return "";
+  if (Array.isArray(value)) {
+    return value.map((entry) => projectionToText(entry)).join("\n");
+  }
+  if (isRecord2(value)) {
+    if ("output" in value) return projectionToText(value.output);
+    if ("value" in value) return projectionToText(value.value);
+    if ("data" in value) return projectionToText(value.data);
+    if ("content" in value) return projectionToText(value.content);
+    if ("body" in value) return projectionToText(value.body);
+    if ("title" in value) return projectionToText(value.title);
+    if ("fullName" in value) return projectionToText(value.fullName);
+    if ("path" in value) return projectionToText(value.path);
+    if ("url" in value) return projectionToText(value.url);
+  }
+  return JSON.stringify(value);
+}
+function resolvePath2(value, path25) {
+  if (!path25) return value;
+  let current = value;
+  for (const segment of path25.split(".")) {
+    if (Array.isArray(current) && /^\d+$/.test(segment)) {
+      current = current[Number(segment)];
+      continue;
+    }
+    if (isRecord2(current)) {
+      current = current[segment];
+      continue;
+    }
+    return void 0;
+  }
+  return current;
+}
+function parseRepositoryRef(repo) {
+  if (typeof repo === "string") {
+    const [owner2, name2, ...rest] = repo.split("/");
+    if (!owner2 || !name2 || rest.length > 0) {
+      throw new Error(`GitHub repo must be in owner/repo format: ${repo}`);
+    }
+    return {
+      owner: owner2,
+      repo: name2,
+      fullName: `${owner2}/${name2}`
+    };
+  }
+  const owner = typeof repo.owner === "string" ? repo.owner : void 0;
+  const name = typeof repo.repo === "string" ? repo.repo : void 0;
+  if (!owner || !name) {
+    throw new Error("GitHub repo object requires owner and repo");
+  }
+  return {
+    owner,
+    repo: name,
+    fullName: typeof repo.fullName === "string" ? repo.fullName : `${owner}/${name}`
+  };
+}
+function repoToString(repo) {
+  return typeof repo === "string" ? repo : `${repo.owner}/${repo.repo}`;
+}
+async function safeGetRuntime(client) {
+  try {
+    return await client.getRuntime();
+  } catch {
+    return void 0;
+  }
+}
+function normalizeResolvedParams(params) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(params)) {
+    normalized[key] = coerceScalar(value);
+  }
+  return normalized;
+}
+function coerceScalar(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null") return null;
+  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(trimmed)) return Number(trimmed);
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+function readJsonParam(value, name) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch (error51) {
+    throw new Error(
+      `GitHub step params.${name} must be valid JSON: ${error51 instanceof Error ? error51.message : String(error51)}`
+    );
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// packages/github-primitive/src/index.ts
+init_branches();
+init_commits();
+init_repos();
+init_issues();
+init_pulls();
+init_files();
+init_users();
+
 // packages/utils/dist/name-generator.js
 var ADJECTIVES = [
   "Blue",
@@ -66508,14 +69292,14 @@ function benchmarkPatterns(iterations = 1e4) {
 }
 
 // packages/utils/dist/command-resolver.js
-var import_node_child_process10 = require("node:child_process");
+var import_node_child_process12 = require("node:child_process");
 var import_node_fs26 = __toESM(require("node:fs"), 1);
 function resolveCommand(command) {
   if (command.startsWith("/")) {
     return resolveSymlinks(command);
   }
   try {
-    const output = (0, import_node_child_process10.execSync)(`which ${command}`, {
+    const output = (0, import_node_child_process12.execSync)(`which ${command}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       // Ensure we have a reasonable PATH
@@ -66549,7 +69333,7 @@ function resolveSymlinks(filePath) {
 }
 function commandExists(command) {
   try {
-    (0, import_node_child_process10.execSync)(`which ${command}`, {
+    (0, import_node_child_process12.execSync)(`which ${command}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -66562,7 +69346,7 @@ function commandExists(command) {
 // packages/utils/dist/git-remote.js
 var fs9 = __toESM(require("node:fs"), 1);
 var path21 = __toESM(require("node:path"), 1);
-var import_node_child_process11 = require("node:child_process");
+var import_node_child_process13 = require("node:child_process");
 function parseGitRemoteUrl(url2) {
   if (!url2)
     return null;
@@ -66582,7 +69366,7 @@ function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
     if (!fs9.existsSync(gitDir)) {
       return null;
     }
-    const result = (0, import_node_child_process11.execSync)(`git remote get-url ${remoteName}`, {
+    const result = (0, import_node_child_process13.execSync)(`git remote get-url ${remoteName}`, {
       cwd: workingDirectory,
       encoding: "utf-8",
       timeout: 5e3,
@@ -67713,7 +70497,7 @@ var HookRegistry = class {
 };
 
 // packages/trajectory/dist/integration.js
-var import_node_child_process12 = require("node:child_process");
+var import_node_child_process14 = require("node:child_process");
 
 // packages/config/dist/project-namespace.js
 var import_node_crypto16 = __toESM(require("node:crypto"), 1);
@@ -67842,7 +70626,7 @@ function getTrajectoryEnvVars(projectRoot) {
 async function runTrail(args) {
   return new Promise((resolve4) => {
     const trajectoryEnv = getTrajectoryEnvVars();
-    const proc = (0, import_node_child_process12.spawn)("trail", args, {
+    const proc = (0, import_node_child_process14.spawn)("trail", args, {
       cwd: getProjectPaths2().projectRoot,
       env: { ...process.env, ...trajectoryEnv },
       stdio: ["pipe", "pipe", "pipe"]
@@ -68113,7 +70897,7 @@ var TrajectoryIntegration = class {
    */
   isTrailInstalledSync() {
     try {
-      (0, import_node_child_process12.execSync)("which trail", { stdio: "pipe" });
+      (0, import_node_child_process14.execSync)("which trail", { stdio: "pipe" });
       return true;
     } catch {
       return false;
@@ -68572,6 +71356,7 @@ init_dist2();
   ERROR_SEARCH_HINT,
   GEMINI_MODEL_OPTIONS,
   GeminiModels,
+  GitHubClient,
   HARNESS_VALUES,
   HOOK_ABI_VERSION,
   HookEmitter,
@@ -68635,6 +71420,7 @@ init_dist2();
   createConsensusEngine,
   createContextCompactor,
   createDefaultEventLogger,
+  createGitHubStep,
   createLogger,
   createMemoryAdapter,
   createMemoryHooks,
@@ -68694,6 +71480,7 @@ init_dist2();
   getSupportedPlatforms,
   getSupportedReasoningEfforts,
   getTrajectoryHooks,
+  github,
   handleResponse,
   hasRelayPtyBinary,
   hasUnreadMessages,