@harness-engineering/orchestrator 0.8.3 → 0.8.4

package/dist/index.d.mts

@@ -296,11 +296,38 @@ declare class PRDetector {
      */
     hasOpenPRForIdentifier(identifier: string): Promise<boolean>;
     /**
-     * Filters out candidates that already have an open GitHub PR, running
-     * checks with limited concurrency to avoid overwhelming the GitHub API.
-     * For candidates with an externalId, searches for PRs linked to the
-     * GitHub issue. Falls back to `feat/<identifier>` branch lookup otherwise.
-     * Fail-open on API errors.
+     * GitHub closing keywords that link a PR to an issue it will close.
+     * @see https://docs.github.com/articles/closing-issues-using-keywords
+     */
+    private static readonly CLOSING_REF_RE;
+    /**
+     * Extracts the issue numbers a PR body declares it will close
+     * (e.g. `Closes #42`, `fixes #7`, `Resolves: #99`).
+     */
+    private parseClosingIssueNumbers;
+    /**
+     * Lists every open PR for a repo in a single `gh pr list` call and returns
+     * the set of issue numbers those PRs close (parsed from their bodies).
+     *
+     * This is the batched replacement for per-issue `gh pr list --search
+     * "closes #N"` queries. Every `gh pr list` form (search or plain list) is
+     * served by GitHub's GraphQL API and consumes from the shared ~5000/hr
+     * GraphQL budget, so issuing one query per candidate per tick exhausted the
+     * limit on busy boards. A single `--state open` list returns every open PR
+     * in one request regardless of candidate count, collapsing N calls into 1.
+     *
+     * Returns `null` if the check itself failed (gh missing, rate limited,
+     * network error) so callers can fail open rather than block real work.
+     */
+    fetchOpenPRClosures(owner: string, repo: string): Promise<Set<number> | null>;
+    /**
+     * Filters out candidates that already have an open GitHub PR.
+     *
+     * For GitHub-issue candidates the check is batched: one `gh pr list` per
+     * distinct repo (not one search per issue), parsing closing references
+     * locally. Candidates without a GitHub externalId fall back to a
+     * `feat/<identifier>` branch lookup, throttled to a few concurrent gh calls.
+     * Fail-open on API errors so a flaky/rate-limited GitHub never blocks work.
      */
     filterCandidatesWithOpenPRs(candidates: Issue[]): Promise<Issue[]>;
 }

package/dist/index.d.ts

@@ -296,11 +296,38 @@ declare class PRDetector {
      */
     hasOpenPRForIdentifier(identifier: string): Promise<boolean>;
     /**
-     * Filters out candidates that already have an open GitHub PR, running
-     * checks with limited concurrency to avoid overwhelming the GitHub API.
-     * For candidates with an externalId, searches for PRs linked to the
-     * GitHub issue. Falls back to `feat/<identifier>` branch lookup otherwise.
-     * Fail-open on API errors.
+     * GitHub closing keywords that link a PR to an issue it will close.
+     * @see https://docs.github.com/articles/closing-issues-using-keywords
+     */
+    private static readonly CLOSING_REF_RE;
+    /**
+     * Extracts the issue numbers a PR body declares it will close
+     * (e.g. `Closes #42`, `fixes #7`, `Resolves: #99`).
+     */
+    private parseClosingIssueNumbers;
+    /**
+     * Lists every open PR for a repo in a single `gh pr list` call and returns
+     * the set of issue numbers those PRs close (parsed from their bodies).
+     *
+     * This is the batched replacement for per-issue `gh pr list --search
+     * "closes #N"` queries. Every `gh pr list` form (search or plain list) is
+     * served by GitHub's GraphQL API and consumes from the shared ~5000/hr
+     * GraphQL budget, so issuing one query per candidate per tick exhausted the
+     * limit on busy boards. A single `--state open` list returns every open PR
+     * in one request regardless of candidate count, collapsing N calls into 1.
+     *
+     * Returns `null` if the check itself failed (gh missing, rate limited,
+     * network error) so callers can fail open rather than block real work.
+     */
+    fetchOpenPRClosures(owner: string, repo: string): Promise<Set<number> | null>;
+    /**
+     * Filters out candidates that already have an open GitHub PR.
+     *
+     * For GitHub-issue candidates the check is batched: one `gh pr list` per
+     * distinct repo (not one search per issue), parsing closing references
+     * locally. Candidates without a GitHub externalId fall back to a
+     * `feat/<identifier>` branch lookup, throttled to a few concurrent gh calls.
+     * Fail-open on API errors so a flaky/rate-limited GitHub never blocks work.
      */
     filterCandidatesWithOpenPRs(candidates: Issue[]): Promise<Issue[]>;
 }

package/dist/index.js

@@ -1341,7 +1341,7 @@ var ClaimManager = class {
 // src/core/pr-detector.ts
 var import_node_child_process = require("child_process");
 var import_node_util = require("util");
-var PRDetector = class {
+var PRDetector = class _PRDetector {
   logger;
   execFileFn;
   projectRoot;
@@ -1457,35 +1457,124 @@ var PRDetector = class {
     }
   }
   /**
-   * Filters out candidates that already have an open GitHub PR, running
-   * checks with limited concurrency to avoid overwhelming the GitHub API.
-   * For candidates with an externalId, searches for PRs linked to the
-   * GitHub issue. Falls back to `feat/<identifier>` branch lookup otherwise.
-   * Fail-open on API errors.
+   * GitHub closing keywords that link a PR to an issue it will close.
+   * @see https://docs.github.com/articles/closing-issues-using-keywords
+   */
+  static CLOSING_REF_RE = /\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)[\s:]+#(\d+)/gi;
+  /**
+   * Extracts the issue numbers a PR body declares it will close
+   * (e.g. `Closes #42`, `fixes #7`, `Resolves: #99`).
+   */
+  parseClosingIssueNumbers(body) {
+    const nums = [];
+    for (const match of body.matchAll(_PRDetector.CLOSING_REF_RE)) {
+      nums.push(parseInt(match[1], 10));
+    }
+    return nums;
+  }
+  /**
+   * Lists every open PR for a repo in a single `gh pr list` call and returns
+   * the set of issue numbers those PRs close (parsed from their bodies).
+   *
+   * This is the batched replacement for per-issue `gh pr list --search
+   * "closes #N"` queries. Every `gh pr list` form (search or plain list) is
+   * served by GitHub's GraphQL API and consumes from the shared ~5000/hr
+   * GraphQL budget, so issuing one query per candidate per tick exhausted the
+   * limit on busy boards. A single `--state open` list returns every open PR
+   * in one request regardless of candidate count, collapsing N calls into 1.
+   *
+   * Returns `null` if the check itself failed (gh missing, rate limited,
+   * network error) so callers can fail open rather than block real work.
+   */
+  async fetchOpenPRClosures(owner, repo) {
+    try {
+      const exec = (0, import_node_util.promisify)(this.execFileFn);
+      const { stdout } = await exec(
+        "gh",
+        [
+          "pr",
+          "list",
+          "--repo",
+          `${owner}/${repo}`,
+          "--state",
+          "open",
+          "--json",
+          "body",
+          "--limit",
+          "200"
+        ],
+        {
+          cwd: this.projectRoot,
+          timeout: 15e3
+        }
+      );
+      const prs = JSON.parse(stdout);
+      const closed = /* @__PURE__ */ new Set();
+      for (const pr of prs) {
+        for (const n of this.parseClosingIssueNumbers(pr.body ?? "")) closed.add(n);
+      }
+      return closed;
+    } catch (err) {
+      this.logger.debug(`Failed to list open PRs for ${owner}/${repo}`, {
+        error: String(err)
+      });
+      return null;
+    }
+  }
+  /**
+   * Filters out candidates that already have an open GitHub PR.
+   *
+   * For GitHub-issue candidates the check is batched: one `gh pr list` per
+   * distinct repo (not one search per issue), parsing closing references
+   * locally. Candidates without a GitHub externalId fall back to a
+   * `feat/<identifier>` branch lookup, throttled to a few concurrent gh calls.
+   * Fail-open on API errors so a flaky/rate-limited GitHub never blocks work.
    */
   async filterCandidatesWithOpenPRs(candidates) {
+    const repos = /* @__PURE__ */ new Map();
+    for (const candidate of candidates) {
+      const parsed = candidate.externalId ? this.parseExternalId(candidate.externalId) : null;
+      if (parsed) repos.set(`${parsed.owner}/${parsed.repo}`, parsed);
+    }
+    const repoClosures = /* @__PURE__ */ new Map();
+    await Promise.all(
+      [...repos.values()].map(async ({ owner, repo }) => {
+        repoClosures.set(`${owner}/${repo}`, await this.fetchOpenPRClosures(owner, repo));
+      })
+    );
+    const identifierCandidates = candidates.filter(
+      (c) => !(c.externalId && this.parseExternalId(c.externalId))
+    );
+    const identifiersWithOpenPR = /* @__PURE__ */ new Set();
     const concurrency = 3;
-    const results = [];
-    for (let i = 0; i < candidates.length; i += concurrency) {
-      const batch = candidates.slice(i, i + concurrency);
-      const batchResults = await Promise.allSettled(
-        batch.map(async (candidate) => {
-          const hasOpenPR = candidate.externalId ? await this.hasOpenPRForExternalId(candidate.externalId) : await this.hasOpenPRForIdentifier(candidate.identifier);
-          return { candidate, hasOpenPR };
-        })
+    for (let i = 0; i < identifierCandidates.length; i += concurrency) {
+      const batch = identifierCandidates.slice(i, i + concurrency);
+      const settled = await Promise.allSettled(
+        batch.map(async (c) => ({
+          identifier: c.identifier,
+          hasOpenPR: await this.hasOpenPRForIdentifier(c.identifier)
+        }))
       );
-      results.push(...batchResults);
+      for (const result of settled) {
+        if (result.status === "fulfilled" && result.value.hasOpenPR) {
+          identifiersWithOpenPR.add(result.value.identifier);
+        }
+      }
     }
     const filtered = [];
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i];
-      if (!result || result.status === "rejected") {
-        filtered.push(candidates[i]);
-        continue;
+    for (const candidate of candidates) {
+      const parsed = candidate.externalId ? this.parseExternalId(candidate.externalId) : null;
+      let hasOpenPR;
+      let via;
+      if (parsed) {
+        const closures = repoClosures.get(`${parsed.owner}/${parsed.repo}`);
+        hasOpenPR = closures ? closures.has(parsed.number) : false;
+        via = `externalId ${candidate.externalId}`;
+      } else {
+        hasOpenPR = identifiersWithOpenPR.has(candidate.identifier);
+        via = `feat/${candidate.identifier}`;
       }
-      const { candidate, hasOpenPR } = result.value;
       if (hasOpenPR) {
-        const via = candidate.externalId ? `externalId ${candidate.externalId}` : `feat/${candidate.identifier}`;
         this.logger.info(`Skipping ${candidate.title}: open PR exists (${via})`);
       } else {
         filtered.push(candidate);
@@ -2309,7 +2398,8 @@ var RoadmapTrackerAdapter = class {
       if (!target) return (0, import_types4.Ok)(void 0);
       const normalizedTerminal = this.config.terminalStates.map((s) => s.toLowerCase());
       if (normalizedTerminal.includes(target.status.toLowerCase())) return (0, import_types4.Ok)(void 0);
-      target.status = terminal;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      (0, import_core.setStatus)(roadmap, target, terminal, now.slice(0, 10));
       await fs8.writeFile(this.config.filePath, (0, import_core.serializeRoadmap)(roadmap), "utf-8");
       return (0, import_types4.Ok)(void 0);
     } catch (error) {
@@ -2330,15 +2420,15 @@ var RoadmapTrackerAdapter = class {
       const roadmap = roadmapResult.value;
       const target = this.findFeatureById(roadmap.milestones, issueId);
       if (!target) return (0, import_types4.Ok)(void 0);
-      if (target.assignee != null && target.assignee !== orchestratorId) {
+      if (!(0, import_core.isClaimableBy)(target, orchestratorId)) {
         return (0, import_types4.Ok)(void 0);
       }
       if (target.status === "in-progress" && target.assignee === orchestratorId) {
         return (0, import_types4.Ok)(void 0);
       }
-      target.status = "in-progress";
-      target.assignee = orchestratorId;
-      target.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      (0, import_core.claim)(roadmap, target, orchestratorId, now.slice(0, 10));
+      target.updatedAt = now;
       await fs8.writeFile(this.config.filePath, (0, import_core.serializeRoadmap)(roadmap), "utf-8");
       return (0, import_types4.Ok)(void 0);
     } catch (error) {
@@ -2365,8 +2455,8 @@ var RoadmapTrackerAdapter = class {
       if (this.config.activeStates.includes(target.status) && target.assignee === null) {
         return (0, import_types4.Ok)(void 0);
       }
-      target.status = activeState;
-      target.assignee = null;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      (0, import_core.setStatus)(roadmap, target, activeState, now.slice(0, 10));
       target.updatedAt = null;
       await fs8.writeFile(this.config.filePath, (0, import_core.serializeRoadmap)(roadmap), "utf-8");
       return (0, import_types4.Ok)(void 0);

package/dist/index.mjs

@@ -1219,7 +1219,7 @@ var ClaimManager = class {
 // src/core/pr-detector.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
-var PRDetector = class {
+var PRDetector = class _PRDetector {
   logger;
   execFileFn;
   projectRoot;
@@ -1335,35 +1335,124 @@ var PRDetector = class {
     }
   }
   /**
-   * Filters out candidates that already have an open GitHub PR, running
-   * checks with limited concurrency to avoid overwhelming the GitHub API.
-   * For candidates with an externalId, searches for PRs linked to the
-   * GitHub issue. Falls back to `feat/<identifier>` branch lookup otherwise.
-   * Fail-open on API errors.
+   * GitHub closing keywords that link a PR to an issue it will close.
+   * @see https://docs.github.com/articles/closing-issues-using-keywords
+   */
+  static CLOSING_REF_RE = /\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)[\s:]+#(\d+)/gi;
+  /**
+   * Extracts the issue numbers a PR body declares it will close
+   * (e.g. `Closes #42`, `fixes #7`, `Resolves: #99`).
+   */
+  parseClosingIssueNumbers(body) {
+    const nums = [];
+    for (const match of body.matchAll(_PRDetector.CLOSING_REF_RE)) {
+      nums.push(parseInt(match[1], 10));
+    }
+    return nums;
+  }
+  /**
+   * Lists every open PR for a repo in a single `gh pr list` call and returns
+   * the set of issue numbers those PRs close (parsed from their bodies).
+   *
+   * This is the batched replacement for per-issue `gh pr list --search
+   * "closes #N"` queries. Every `gh pr list` form (search or plain list) is
+   * served by GitHub's GraphQL API and consumes from the shared ~5000/hr
+   * GraphQL budget, so issuing one query per candidate per tick exhausted the
+   * limit on busy boards. A single `--state open` list returns every open PR
+   * in one request regardless of candidate count, collapsing N calls into 1.
+   *
+   * Returns `null` if the check itself failed (gh missing, rate limited,
+   * network error) so callers can fail open rather than block real work.
+   */
+  async fetchOpenPRClosures(owner, repo) {
+    try {
+      const exec = promisify(this.execFileFn);
+      const { stdout } = await exec(
+        "gh",
+        [
+          "pr",
+          "list",
+          "--repo",
+          `${owner}/${repo}`,
+          "--state",
+          "open",
+          "--json",
+          "body",
+          "--limit",
+          "200"
+        ],
+        {
+          cwd: this.projectRoot,
+          timeout: 15e3
+        }
+      );
+      const prs = JSON.parse(stdout);
+      const closed = /* @__PURE__ */ new Set();
+      for (const pr of prs) {
+        for (const n of this.parseClosingIssueNumbers(pr.body ?? "")) closed.add(n);
+      }
+      return closed;
+    } catch (err) {
+      this.logger.debug(`Failed to list open PRs for ${owner}/${repo}`, {
+        error: String(err)
+      });
+      return null;
+    }
+  }
+  /**
+   * Filters out candidates that already have an open GitHub PR.
+   *
+   * For GitHub-issue candidates the check is batched: one `gh pr list` per
+   * distinct repo (not one search per issue), parsing closing references
+   * locally. Candidates without a GitHub externalId fall back to a
+   * `feat/<identifier>` branch lookup, throttled to a few concurrent gh calls.
+   * Fail-open on API errors so a flaky/rate-limited GitHub never blocks work.
    */
   async filterCandidatesWithOpenPRs(candidates) {
+    const repos = /* @__PURE__ */ new Map();
+    for (const candidate of candidates) {
+      const parsed = candidate.externalId ? this.parseExternalId(candidate.externalId) : null;
+      if (parsed) repos.set(`${parsed.owner}/${parsed.repo}`, parsed);
+    }
+    const repoClosures = /* @__PURE__ */ new Map();
+    await Promise.all(
+      [...repos.values()].map(async ({ owner, repo }) => {
+        repoClosures.set(`${owner}/${repo}`, await this.fetchOpenPRClosures(owner, repo));
+      })
+    );
+    const identifierCandidates = candidates.filter(
+      (c) => !(c.externalId && this.parseExternalId(c.externalId))
+    );
+    const identifiersWithOpenPR = /* @__PURE__ */ new Set();
     const concurrency = 3;
-    const results = [];
-    for (let i = 0; i < candidates.length; i += concurrency) {
-      const batch = candidates.slice(i, i + concurrency);
-      const batchResults = await Promise.allSettled(
-        batch.map(async (candidate) => {
-          const hasOpenPR = candidate.externalId ? await this.hasOpenPRForExternalId(candidate.externalId) : await this.hasOpenPRForIdentifier(candidate.identifier);
-          return { candidate, hasOpenPR };
-        })
+    for (let i = 0; i < identifierCandidates.length; i += concurrency) {
+      const batch = identifierCandidates.slice(i, i + concurrency);
+      const settled = await Promise.allSettled(
+        batch.map(async (c) => ({
+          identifier: c.identifier,
+          hasOpenPR: await this.hasOpenPRForIdentifier(c.identifier)
+        }))
       );
-      results.push(...batchResults);
+      for (const result of settled) {
+        if (result.status === "fulfilled" && result.value.hasOpenPR) {
+          identifiersWithOpenPR.add(result.value.identifier);
+        }
+      }
     }
     const filtered = [];
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i];
-      if (!result || result.status === "rejected") {
-        filtered.push(candidates[i]);
-        continue;
+    for (const candidate of candidates) {
+      const parsed = candidate.externalId ? this.parseExternalId(candidate.externalId) : null;
+      let hasOpenPR;
+      let via;
+      if (parsed) {
+        const closures = repoClosures.get(`${parsed.owner}/${parsed.repo}`);
+        hasOpenPR = closures ? closures.has(parsed.number) : false;
+        via = `externalId ${candidate.externalId}`;
+      } else {
+        hasOpenPR = identifiersWithOpenPR.has(candidate.identifier);
+        via = `feat/${candidate.identifier}`;
       }
-      const { candidate, hasOpenPR } = result.value;
       if (hasOpenPR) {
-        const via = candidate.externalId ? `externalId ${candidate.externalId}` : `feat/${candidate.identifier}`;
         this.logger.info(`Skipping ${candidate.title}: open PR exists (${via})`);
       } else {
         filtered.push(candidate);
@@ -2124,7 +2213,10 @@ import * as fs8 from "fs/promises";
 import { createHash as createHash2 } from "crypto";
 import {
   parseRoadmap,
-  serializeRoadmap
+  serializeRoadmap,
+  claim as claimFeature,
+  setStatus as setFeatureStatus,
+  isClaimableBy
 } from "@harness-engineering/core";
 import {
   Ok as Ok4,
@@ -2197,7 +2289,8 @@ var RoadmapTrackerAdapter = class {
       if (!target) return Ok4(void 0);
       const normalizedTerminal = this.config.terminalStates.map((s) => s.toLowerCase());
       if (normalizedTerminal.includes(target.status.toLowerCase())) return Ok4(void 0);
-      target.status = terminal;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      setFeatureStatus(roadmap, target, terminal, now.slice(0, 10));
       await fs8.writeFile(this.config.filePath, serializeRoadmap(roadmap), "utf-8");
       return Ok4(void 0);
     } catch (error) {
@@ -2218,15 +2311,15 @@ var RoadmapTrackerAdapter = class {
       const roadmap = roadmapResult.value;
       const target = this.findFeatureById(roadmap.milestones, issueId);
       if (!target) return Ok4(void 0);
-      if (target.assignee != null && target.assignee !== orchestratorId) {
+      if (!isClaimableBy(target, orchestratorId)) {
         return Ok4(void 0);
       }
       if (target.status === "in-progress" && target.assignee === orchestratorId) {
         return Ok4(void 0);
       }
-      target.status = "in-progress";
-      target.assignee = orchestratorId;
-      target.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      claimFeature(roadmap, target, orchestratorId, now.slice(0, 10));
+      target.updatedAt = now;
       await fs8.writeFile(this.config.filePath, serializeRoadmap(roadmap), "utf-8");
       return Ok4(void 0);
     } catch (error) {
@@ -2253,8 +2346,8 @@ var RoadmapTrackerAdapter = class {
       if (this.config.activeStates.includes(target.status) && target.assignee === null) {
         return Ok4(void 0);
       }
-      target.status = activeState;
-      target.assignee = null;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      setFeatureStatus(roadmap, target, activeState, now.slice(0, 10));
       target.updatedAt = null;
       await fs8.writeFile(this.config.filePath, serializeRoadmap(roadmap), "utf-8");
       return Ok4(void 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-engineering/orchestrator",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "Orchestrator daemon for dispatching coding agents to issues",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -48,10 +48,10 @@
     "ws": "^8.21.0",
     "yaml": "^2.8.3",
     "zod": "^3.25.76",
-    "@harness-engineering/core": "0.30.1",
+    "@harness-engineering/core": "0.31.0",
     "@harness-engineering/graph": "0.11.1",
-    "@harness-engineering/types": "0.16.1",
-    "@harness-engineering/intelligence": "0.3.1"
+    "@harness-engineering/intelligence": "0.3.1",
+    "@harness-engineering/types": "0.16.1"
   },
   "devDependencies": {
     "@asteasolutions/zod-to-openapi": "^7.3.0",