@gh-symphony/cli 0.0.16 → 0.0.18

package/dist/{chunk-EFMFGOWM.js → chunk-LZE6YUSB.js}

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import {
+  DEFAULT_MAX_FAILURE_RETRIES,
   DEFAULT_WORKFLOW_LIFECYCLE,
   WorkflowConfigStore,
   buildHookEnv,
@@ -25,7 +26,7 @@ import {
   resolveIssueWorkspaceDirectory,
   safeReadDir,
   scheduleRetryAt
-} from "./chunk-TF3QNWNC.js";
+} from "./chunk-OL73UN2X.js";
 
 // ../orchestrator/dist/service.js
 import { mkdir as mkdir3, readFile as readFile3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
@@ -286,7 +287,8 @@ var OrchestratorFsStore = class {
     if (issues) {
       return issues.map((issue) => ({
         ...issue,
-        completedOnce: issue.completedOnce ?? false
+        completedOnce: issue.completedOnce ?? false,
+        failureRetryCount: issue.failureRetryCount ?? 0
       }));
     }
     const legacyLeases = await readJsonFile(join2(this.projectDir(projectId), "leases.json")) ?? [];
@@ -298,6 +300,7 @@ var OrchestratorFsStore = class {
       identifier: lease.issueIdentifier,
       workspaceKey: deriveIssueWorkspaceKeyFromIdentifier(lease.issueIdentifier),
       completedOnce: false,
+      failureRetryCount: 0,
       state: lease.status === "active" ? "claimed" : "released",
       currentRunId: lease.status === "active" ? lease.runId : null,
       retryEntry: null,
@@ -464,9 +467,12 @@ async function pathExists(path) {
 }
 
 // ../tracker-github/dist/adapter.js
+import { createHash } from "crypto";
 var DEFAULT_API_URL = "https://api.github.com/graphql";
 var DEFAULT_PAGE_SIZE = 25;
 var DEFAULT_NETWORK_TIMEOUT_MS = 3e4;
+var RATE_LIMIT_THRESHOLD = 100;
+var MAX_RATE_LIMIT_WAIT_MS = 6e4;
 var GitHubTrackerError = class extends Error {
 };
 var GitHubTrackerHttpError = class extends GitHubTrackerError {
@@ -480,6 +486,7 @@ var GitHubTrackerHttpError = class extends GitHubTrackerError {
 };
 var GitHubTrackerQueryError = class extends GitHubTrackerError {
 };
+var cachedGitHubGraphQLRateLimits = /* @__PURE__ */ new Map();
 function normalizeProjectItem(projectId, item, lifecycle = DEFAULT_WORKFLOW_LIFECYCLE, priority = {}, rateLimits = null) {
   if (item.content?.__typename !== "Issue") {
     return null;
@@ -814,6 +821,8 @@ async function executeGraphQLQuery(config, query, variables, fetchImpl) {
   return result.data;
 }
 async function executeGraphQLQueryWithMetadata(config, query, variables, fetchImpl) {
+  const tokenFingerprint = fingerprintToken(config.token);
+  await guardGraphQLRateLimit(tokenFingerprint);
   const response = await fetchImpl(config.apiUrl ?? DEFAULT_API_URL, {
     method: "POST",
     headers: {
@@ -838,11 +847,38 @@ async function executeGraphQLQueryWithMetadata(config, query, variables, fetchIm
     throw new GitHubTrackerQueryError("GitHub GraphQL response did not include data.");
   }
   const data = payload.data;
+  const rateLimits = extractGitHubRateLimits(response.headers);
+  cachedGitHubGraphQLRateLimits.set(tokenFingerprint, rateLimits);
   return {
     data,
-    rateLimits: extractGitHubRateLimits(response.headers)
+    rateLimits
   };
 }
+async function guardGraphQLRateLimit(tokenFingerprint) {
+  const rateLimit = cachedGitHubGraphQLRateLimits.get(tokenFingerprint) ?? null;
+  if (!rateLimit) {
+    return;
+  }
+  const remaining = rateLimit.remaining;
+  if (remaining === null || remaining > RATE_LIMIT_THRESHOLD) {
+    return;
+  }
+  const resetAtMs = parseTimestampMs(rateLimit.resetAt);
+  if (resetAtMs === null) {
+    throw new GitHubTrackerError("Rate limit near exhaustion");
+  }
+  const waitMs = Math.max(0, resetAtMs - Date.now());
+  if (waitMs > MAX_RATE_LIMIT_WAIT_MS) {
+    throw new GitHubTrackerError("Rate limit near exhaustion");
+  }
+  cachedGitHubGraphQLRateLimits.delete(tokenFingerprint);
+  if (waitMs > 0) {
+    await sleep(waitMs);
+  }
+}
+function fingerprintToken(token) {
+  return createHash("sha256").update(token).digest("hex");
+}
 function extractGitHubRateLimits(headers) {
   if (!headers || typeof headers.get !== "function") {
     return null;
@@ -872,6 +908,18 @@ function parseIntegerHeader(value) {
   const parsed = Number.parseInt(value, 10);
   return Number.isFinite(parsed) ? parsed : null;
 }
+function parseTimestampMs(value) {
+  if (!value) {
+    return null;
+  }
+  const timestampMs = Date.parse(value);
+  return Number.isFinite(timestampMs) ? timestampMs : null;
+}
+function sleep(ms) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
+  });
+}
 var PROJECT_ITEMS_QUERY = `
   query ProjectItems($projectId: ID!, $cursor: String, $pageSize: Int!) {
     node(id: $projectId) {
@@ -1086,7 +1134,7 @@ var ISSUE_PROJECT_ITEMS_PAGE_QUERY = `
 `;
 
 // ../tracker-github/dist/orchestrator-adapter.js
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 var githubProjectTrackerAdapter = {
   async listIssues(project, dependencies = {}) {
     return listProjectIssues(project, dependencies);
@@ -1174,7 +1222,7 @@ function hashToken(token) {
   if (!token) {
     return null;
   }
-  return createHash("sha256").update(token).digest("hex");
+  return createHash2("sha256").update(token).digest("hex");
 }
 var trackerAdapters = {
   "github-project": githubProjectTrackerAdapter
@@ -1333,19 +1381,33 @@ var DEFAULT_POLL_INTERVAL_MS = 3e4;
 var DEFAULT_CONCURRENCY = 3;
 var DEFAULT_RETRY_BACKOFF_MS = 3e4;
 var CONTINUATION_RETRY_DELAY_MS = 1e3;
+var DEFAULT_GLOBAL_MAX_TURNS = 100;
+var DEFAULT_MAX_TOKENS = 256e3;
 var DEFAULT_WORKER_COMMAND = "node packages/worker/dist/index.js";
 var DEFAULT_MAX_NONPRODUCTIVE_TURNS = 3;
+var LOW_RATE_LIMIT_WARNING_THRESHOLD = 0.05;
+var MAX_FAILURE_RETRIES_EXCEEDED_REASON = "max_failure_retries_exceeded";
 var STUCK_WORKER_TIMEOUT_MS = 30 * 60 * 1e3;
 function isUsableWorkflowResolution(resolution) {
   return resolution.isValid || resolution.usedLastKnownGood;
 }
-function parseTimestampMs(value) {
+function parseTimestampMs2(value) {
   if (!value) {
     return null;
   }
   const parsed = new Date(value).getTime();
   return Number.isFinite(parsed) ? parsed : null;
 }
+function parseFiniteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
 var OrchestratorService = class {
   store;
   projectConfig;
@@ -1513,11 +1575,12 @@ var OrchestratorService = class {
     let recovered = 0;
     let pollIntervalMs = DEFAULT_POLL_INTERVAL_MS;
     let rateLimits = null;
+    let trackerRateLimits = null;
     let issueRecords = await this.store.loadProjectIssueOrchestrations(tenant.projectId);
     const allRuns = (await this.store.loadAllRuns()).filter((run) => run.projectId === tenant.projectId);
     const activeRuns = allRuns.filter((run) => isActiveRunStatus(run.status));
     for (const run of activeRuns) {
-      const outcome = await this.reconcileRun(tenant, run, issueRecords);
+      const outcome = await this.reconcileRun(tenant, run, issueRecords, trackerDependencies);
       issueRecords = outcome.issueRecords;
       if (outcome.recovered) {
         recovered += 1;
@@ -1555,9 +1618,11 @@ var OrchestratorService = class {
         });
       }
       rateLimits = resolveProjectRateLimits(syncedActiveRuns, trackedIssuesByIdentifier.values());
+      trackerRateLimits = resolveTrackerRateLimits(trackedIssuesByIdentifier.values());
       const concurrency = await this.getProjectConcurrency(tenant);
       const currentlyActive = issueRecords.filter((record) => isIssueOrchestrationClaimed(record.state)).length;
       const availableSlots = Math.max(0, concurrency - currentlyActive);
+      const latestRunsByIssueId = buildLatestRunMapByIssueId(projectRunsAfterReconcile);
       const unscheduledCandidates = actionableCandidates.filter((issue) => {
         if (hasConvergenceLockedRun(projectRunsAfterReconcile, issue.id, issue.state)) {
           return false;
@@ -1579,6 +1644,9 @@ var OrchestratorService = class {
         }
         if (slotsRemaining <= 0)
           break;
+        if (await this.isFailureRetrySuppressedIssue(tenant, issue, issueRecords, latestRunsByIssueId.get(issue.id) ?? null)) {
+          continue;
+        }
         if (isIssueBudgetExceeded(resolveIssueBudgetSnapshot(projectRunsAfterReconcile, issue.id), now)) {
           continue;
         }
@@ -1599,6 +1667,7 @@ var OrchestratorService = class {
           identifier: issue.identifier,
           workspaceKey: preferredWorkspaceKey,
           state: "claimed",
+          failureRetryCount: 0,
           currentRunId: null,
           retryEntry: null,
           updatedAt: now.toISOString()
@@ -1680,7 +1749,11 @@ var OrchestratorService = class {
     } catch (error) {
       lastError = error instanceof Error ? error.message : "Unknown orchestration error";
     }
-    this.projectPollIntervals.set(tenant.projectId, pollIntervalMs);
+    const effectivePollIntervalMs = resolveAdaptivePollIntervalMs(pollIntervalMs, trackerRateLimits);
+    if (effectivePollIntervalMs > pollIntervalMs && isLowRateLimit(trackerRateLimits, LOW_RATE_LIMIT_WARNING_THRESHOLD)) {
+      this.writeStderr(`[orchestrator] low GitHub rate limit for ${tenant.projectId}: interval=${effectivePollIntervalMs}ms rateLimits=${JSON.stringify(trackerRateLimits)}`);
+    }
+    this.projectPollIntervals.set(tenant.projectId, effectivePollIntervalMs);
     await this.store.saveProjectIssueOrchestrations(tenant.projectId, issueRecords);
     const allTenantRuns = (await this.store.loadAllRuns()).filter((run) => run.projectId === tenant.projectId);
     const latestRuns = allTenantRuns.filter((run) => isActiveRunStatus(run.status));
@@ -1874,26 +1947,9 @@ var OrchestratorService = class {
       if (!lifecycle) {
         lifecycle = resolution.lifecycle;
       }
-      if (!isStateActive(issue.state, resolution.lifecycle)) {
+      if (!this.isIssueCandidateEligible(issue, resolution.lifecycle, issues)) {
         continue;
       }
-      if (matchesWorkflowState(issue.state, resolution.lifecycle.blockerCheckStates) && issue.blockedBy.length > 0) {
-        const hasNonTerminalBlocker = issue.blockedBy.some((blockerRef) => {
-          if (blockerRef.state && isStateTerminal(blockerRef.state, resolution.lifecycle)) {
-            return false;
-          }
-          if (blockerRef.identifier) {
-            const blockerIssue = issues.find((candidate) => candidate.identifier === blockerRef.identifier);
-            if (blockerIssue?.state) {
-              return !isStateTerminal(blockerIssue.state, resolution.lifecycle);
-            }
-          }
-          return true;
-        });
-        if (hasNonTerminalBlocker) {
-          continue;
-        }
-      }
       candidates.push(issue);
     }
     if (!lifecycle && tenant.repositories.length > 0) {
@@ -1912,6 +1968,26 @@ var OrchestratorService = class {
       }
     };
   }
+  isIssueCandidateEligible(issue, lifecycle, issues) {
+    if (!isStateActive(issue.state, lifecycle)) {
+      return false;
+    }
+    if (!matchesWorkflowState(issue.state, lifecycle.blockerCheckStates) || issue.blockedBy.length === 0) {
+      return true;
+    }
+    return !issue.blockedBy.some((blockerRef) => {
+      if (blockerRef.state && isStateTerminal(blockerRef.state, lifecycle)) {
+        return false;
+      }
+      if (blockerRef.identifier) {
+        const blockerIssue = issues.find((candidate) => candidate.identifier === blockerRef.identifier);
+        if (blockerIssue?.state) {
+          return !isStateTerminal(blockerIssue.state, lifecycle);
+        }
+      }
+      return true;
+    });
+  }
   async loadProjectWorkflow(tenant, repository) {
     const cacheKey = this.workflowCacheKey(repository);
     const pendingCache = this.workflowResolutionCache;
@@ -2233,13 +2309,13 @@ var OrchestratorService = class {
       issuesByIdentifier
     };
   }
-  async reconcileRun(tenant, run, issueRecords) {
+  async reconcileRun(tenant, run, issueRecords, trackerDependencies = {}) {
     const now = this.now();
     if (run.processId && this.isProcessRunning(run.processId)) {
       const retryPolicy = await this.loadRetryPolicy(tenant, run.repository);
       const configuredStallTimeoutMs = retryPolicy?.stallTimeoutMs ?? null;
-      const lastActivityAtMs = parseTimestampMs(run.lastEventAt ?? run.startedAt);
-      const startedAtMs = parseTimestampMs(run.startedAt);
+      const lastActivityAtMs = parseTimestampMs2(run.lastEventAt ?? run.startedAt);
+      const startedAtMs = parseTimestampMs2(run.startedAt);
       const elapsedSinceLastActivityMs = lastActivityAtMs === null ? null : now.getTime() - lastActivityAtMs;
       const runningSinceMs = startedAtMs === null ? null : now.getTime() - startedAtMs;
       const isStalledByWorkflowTimeout = configuredStallTimeoutMs !== null && configuredStallTimeoutMs > 0 && elapsedSinceLastActivityMs !== null && elapsedSinceLastActivityMs > configuredStallTimeoutMs;
@@ -2318,7 +2394,7 @@ var OrchestratorService = class {
           recovered: false
         };
       }
-      if (await this.resolveRetryRestartAction(tenant, run) === "release") {
+      if (await this.resolveRetryRestartAction(tenant, run, trackerDependencies) === "release") {
         return this.releaseRetryingRun(runWithTokens, issueRecords, now);
       }
       return this.restartRun(tenant, run, issueRecords, now, workerSessionId);
@@ -2355,7 +2431,54 @@ var OrchestratorService = class {
         state: run.issueState
       });
     }
-    const retryKind = await this.classifyRetryKind(tenant, run);
+    const retryKind = await this.classifyRetryKind(tenant, run, trackerDependencies);
+    const failureRetryCount = retryKind === "failure" ? (this.resolveFailureRetryCount(issueRecords, run.issueId) ?? 0) + 1 : this.resolveFailureRetryCount(issueRecords, run.issueId) ?? 0;
+    const maxFailureRetries = await this.loadMaxFailureRetries(tenant, run.repository);
+    if (retryKind === "failure" && failureRetryCount >= maxFailureRetries) {
+      const lastError = [
+        `Run suppressed: ${MAX_FAILURE_RETRIES_EXCEEDED_REASON}.`,
+        `failureRetryCount=${failureRetryCount}.`,
+        `maxFailureRetries=${maxFailureRetries}.`
+      ].join(" ");
+      const suppressedRun = {
+        ...runWithTokens,
+        status: "suppressed",
+        processId: null,
+        updatedAt: now.toISOString(),
+        completedAt: now.toISOString(),
+        nextRetryAt: null,
+        retryKind: null,
+        runPhase: runWithTokens.runPhase ?? "failed",
+        lastError
+      };
+      await this.store.saveRun(suppressedRun);
+      await this.store.appendRunEvent(run.runId, {
+        at: now.toISOString(),
+        event: "run-suppressed",
+        projectId: run.projectId,
+        issueIdentifier: run.issueIdentifier,
+        issueId: run.issueId,
+        reason: MAX_FAILURE_RETRIES_EXCEEDED_REASON
+      });
+      this.logVerbose(`[run-completed] ${suppressedRun.runId} status=${suppressedRun.status}`);
+      return {
+        issueRecords: upsertIssueOrchestration(issueRecords, {
+          issueId: run.issueId,
+          identifier: run.issueIdentifier,
+          workspaceKey: run.issueWorkspaceKey ?? deriveIssueWorkspaceKey({
+            projectId: tenant.projectId,
+            adapter: tenant.tracker.adapter,
+            issueSubjectId: run.issueSubjectId
+          }, run.issueIdentifier),
+          state: "released",
+          failureRetryCount,
+          currentRunId: null,
+          retryEntry: null,
+          updatedAt: now.toISOString()
+        }),
+        recovered: false
+      };
+    }
     let nextRetryAt;
     if (retryKind === "continuation") {
       nextRetryAt = new Date(now.getTime() + CONTINUATION_RETRY_DELAY_MS).toISOString();
@@ -2391,6 +2514,7 @@ var OrchestratorService = class {
       }, run.issueIdentifier),
       state: "retry_queued",
       completedOnce: retryKind === "continuation" ? true : void 0,
+      failureRetryCount,
       currentRunId: run.runId,
       retryEntry: {
         attempt: retryRecord.attempt,
@@ -2605,49 +2729,47 @@ var OrchestratorService = class {
    * — the worker completed its session and the issue hasn't transitioned away.
    * Failure applies when we cannot confirm the issue is still actionable.
    */
-  async classifyRetryKind(tenant, run) {
+  async classifyRetryKind(tenant, run, trackerDependencies = {}) {
     try {
-      const trackerAdapter = resolveTrackerAdapter2(tenant.tracker);
-      const issues = await trackerAdapter.listIssues(tenant, {
-        fetchImpl: this.dependencies.fetchImpl
-      });
-      const runIssue = issues.find((issue) => issue.identifier === run.issueIdentifier);
-      if (!runIssue) {
+      const eligibleContext = await this.fetchTrackedIssueEligibilityContext(tenant, run.issueIdentifier, trackerDependencies);
+      if (!eligibleContext) {
         return "failure";
       }
       const resolution = await this.loadProjectWorkflow(tenant, run.repository);
       if (!isUsableWorkflowResolution(resolution)) {
         return "failure";
       }
-      return isStateActive(runIssue.state, resolution.lifecycle) ? "continuation" : "failure";
+      return this.isIssueCandidateEligible(eligibleContext.issue, resolution.lifecycle, eligibleContext.issues) ? "continuation" : "failure";
     } catch {
       return "failure";
     }
   }
-  async resolveRetryRestartAction(tenant, run) {
+  async resolveRetryRestartAction(tenant, run, trackerDependencies = {}) {
     try {
       if (isIssueBudgetExceeded(resolveIssueBudgetSnapshot((await this.store.loadAllRuns()).filter((candidate) => candidate.projectId === tenant.projectId), run.issueId), this.now())) {
         return "release";
       }
-      const runIssue = await this.fetchTrackedIssueById(tenant, run.issueId);
-      if (!runIssue) {
+      const eligibleContext = await this.fetchTrackedIssueEligibilityContext(tenant, run.issueIdentifier, trackerDependencies);
+      if (!eligibleContext) {
         return "release";
       }
       const resolution = await this.loadProjectWorkflow(tenant, run.repository);
       if (!isUsableWorkflowResolution(resolution)) {
         return "restart";
       }
-      return isStateActive(runIssue.state, resolution.lifecycle) ? "restart" : "release";
+      return this.isIssueCandidateEligible(eligibleContext.issue, resolution.lifecycle, eligibleContext.issues) ? "restart" : "release";
     } catch {
       return "restart";
     }
   }
-  async fetchTrackedIssueById(tenant, issueId) {
+  async fetchTrackedIssueEligibilityContext(tenant, issueIdentifier, trackerDependencies = {}) {
     const trackerAdapter = resolveTrackerAdapter2(tenant.tracker);
-    const issues = await trackerAdapter.fetchIssueStatesByIds(tenant, [issueId], {
-      fetchImpl: this.dependencies.fetchImpl
+    const issues = await trackerAdapter.listIssues(tenant, {
+      fetchImpl: this.dependencies.fetchImpl,
+      ...trackerDependencies
     });
-    return issues[0] ?? null;
+    const issue = issues.find((candidate) => candidate.identifier === issueIdentifier);
+    return issue ? { issue, issues } : null;
   }
   async fetchWorkerRunInfo(run) {
     const latestRun = await this.store.loadRun(run.runId, run.projectId) ?? run;
@@ -3020,6 +3142,36 @@ var OrchestratorService = class {
     };
     await this.store.saveIssueWorkspace(removedRecord);
   }
+  resolveFailureRetryCount(issueRecords, issueId) {
+    return issueRecords.find((record) => record.issueId === issueId)?.failureRetryCount ?? null;
+  }
+  async isFailureRetrySuppressedIssue(tenant, issue, issueRecords, latestRun) {
+    const issueRecord = issueRecords.find((record) => record.issueId === issue.id || record.identifier === issue.identifier) ?? null;
+    if (!issueRecord || issueRecord.failureRetryCount <= 0) {
+      return false;
+    }
+    const maxFailureRetries = await this.loadMaxFailureRetries(tenant, issue.repository);
+    if (issueRecord.failureRetryCount < maxFailureRetries) {
+      return false;
+    }
+    if (!latestRun || latestRun.status !== "suppressed" || latestRun.issueState !== issue.state || !latestRun.lastError?.includes(MAX_FAILURE_RETRIES_EXCEEDED_REASON)) {
+      return false;
+    }
+    const issueUpdatedAtMs = parseTimestampMs2(issue.updatedAt);
+    const suppressedAtMs = parseTimestampMs2(latestRun.completedAt ?? latestRun.updatedAt);
+    if (issueUpdatedAtMs === null || suppressedAtMs === null) {
+      return true;
+    }
+    return issueUpdatedAtMs <= suppressedAtMs;
+  }
+  async loadMaxFailureRetries(tenant, repository) {
+    try {
+      const resolution = await this.loadProjectWorkflow(tenant, repository);
+      return isUsableWorkflowResolution(resolution) ? resolution.workflow.agent.maxFailureRetries : DEFAULT_MAX_FAILURE_RETRIES;
+    } catch {
+      return DEFAULT_MAX_FAILURE_RETRIES;
+    }
+  }
 };
 function hasTokenUsage(tokenUsage) {
   return Boolean(tokenUsage && (tokenUsage.inputTokens > 0 || tokenUsage.outputTokens > 0 || tokenUsage.totalTokens > 0));
@@ -3034,7 +3186,7 @@ function resolveProjectRateLimits(runs, issues) {
     if (!isRecord(run.rateLimits)) {
       continue;
     }
-    const timestamp = parseTimestampMs(run.lastEventAt ?? run.updatedAt ?? run.startedAt);
+    const timestamp = parseTimestampMs2(run.lastEventAt ?? run.updatedAt ?? run.startedAt);
     const sortableTimestamp = timestamp ?? -Infinity;
     if (sortableTimestamp >= latestRunTimestamp) {
       latestRunTimestamp = sortableTimestamp;
@@ -3051,6 +3203,51 @@ function resolveProjectRateLimits(runs, issues) {
   }
   return null;
 }
+function resolveTrackerRateLimits(issues) {
+  for (const issue of issues) {
+    if (isGitHubTrackerRateLimits(issue.rateLimits)) {
+      return issue.rateLimits;
+    }
+  }
+  return null;
+}
+function resolveAdaptivePollIntervalMs(basePollIntervalMs, rateLimits) {
+  if (!Number.isFinite(basePollIntervalMs) || basePollIntervalMs <= 0) {
+    return DEFAULT_POLL_INTERVAL_MS;
+  }
+  const ratio = extractRateLimitRatio(rateLimits);
+  if (ratio === null || ratio > 0.5) {
+    return basePollIntervalMs;
+  }
+  if (ratio >= 0.2) {
+    return basePollIntervalMs * 2;
+  }
+  if (ratio >= LOW_RATE_LIMIT_WARNING_THRESHOLD) {
+    return basePollIntervalMs * 4;
+  }
+  return basePollIntervalMs * 10;
+}
+function extractRateLimitRatio(rateLimits) {
+  if (!isRecord(rateLimits)) {
+    return null;
+  }
+  const limit = parseFiniteNumber(rateLimits.limit);
+  const remaining = parseFiniteNumber(rateLimits.remaining);
+  if (limit === null || remaining === null || limit <= 0 || remaining < 0) {
+    return null;
+  }
+  return remaining / limit;
+}
+function isGitHubTrackerRateLimits(rateLimits) {
+  if (!isRecord(rateLimits) || rateLimits.source !== "github") {
+    return false;
+  }
+  return rateLimits.resource === void 0 || rateLimits.resource === null || rateLimits.resource === "graphql";
+}
+function isLowRateLimit(rateLimits, threshold) {
+  const ratio = extractRateLimitRatio(rateLimits);
+  return ratio !== null && ratio < threshold;
+}
 function buildRuntimeSession(existing, sessionId, threadId, status, startedAt, updatedAt, exitClassification = void 0) {
   if (existing === void 0 && sessionId === null && threadId === null && status === null && (exitClassification === void 0 || exitClassification === null)) {
     return void 0;
@@ -3089,12 +3286,12 @@ function resolveIssueBudgetSnapshot(runs, issueId) {
   };
 }
 function isIssueBudgetExceeded(snapshot, now, env = process.env) {
-  const globalMaxTurns = parsePositiveInteger(env.SYMPHONY_GLOBAL_MAX_TURNS ?? "");
-  if (globalMaxTurns !== null && snapshot.cumulativeTurnCount >= globalMaxTurns) {
+  const globalMaxTurns = parsePositiveInteger(env.SYMPHONY_GLOBAL_MAX_TURNS ?? "") ?? DEFAULT_GLOBAL_MAX_TURNS;
+  if (snapshot.cumulativeTurnCount >= globalMaxTurns) {
     return true;
   }
-  const maxTokens = parsePositiveInteger(env.SYMPHONY_MAX_TOKENS ?? "");
-  if (maxTokens !== null && snapshot.tokenUsage.totalTokens >= maxTokens) {
+  const maxTokens = parsePositiveInteger(env.SYMPHONY_MAX_TOKENS ?? "") ?? DEFAULT_MAX_TOKENS;
+  if (snapshot.tokenUsage.totalTokens >= maxTokens) {
     return true;
   }
   const sessionTimeoutMs = parsePositiveInteger(env.SYMPHONY_SESSION_TIMEOUT_MS ?? "");
@@ -3208,6 +3405,22 @@ function createRunId(now, projectId, issueIdentifier) {
     now.getTime().toString(36)
   ].join("-");
 }
+function buildLatestRunMapByIssueId(runs) {
+  const latestRuns = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    const existing = latestRuns.get(run.issueId);
+    if (!existing) {
+      latestRuns.set(run.issueId, run);
+      continue;
+    }
+    const runUpdatedAtMs = parseTimestampMs2(run.updatedAt) ?? -Infinity;
+    const existingUpdatedAtMs = parseTimestampMs2(existing.updatedAt) ?? -Infinity;
+    if (runUpdatedAtMs > existingUpdatedAtMs) {
+      latestRuns.set(run.issueId, run);
+    }
+  }
+  return latestRuns;
+}
 function isIssueOrchestrationClaimed(state) {
   return state === "claimed" || state === "running" || state === "retry_queued";
 }
@@ -3218,7 +3431,8 @@ function upsertIssueOrchestration(issueRecords, nextRecord) {
     ...remaining,
     {
       ...nextRecord,
-      completedOnce: nextRecord.completedOnce ?? existingRecord?.completedOnce ?? false
+      completedOnce: nextRecord.completedOnce ?? existingRecord?.completedOnce ?? false,
+      failureRetryCount: nextRecord.failureRetryCount ?? existingRecord?.failureRetryCount ?? 0
     }
   ];
 }