agents-relay 1.0.137 → 1.0.139

package/dist/dashboard-html.js

@@ -372,7 +372,8 @@ function usageProvider(provider){const card=element('section','usage-provider');
 function formatCredit(value,currency){if(value===null||value===undefined||!Number.isFinite(Number(value)))return '—';const number=Number(value);if(currency==='USD')return '$'+number.toFixed(2);if(currency==='CNY')return '¥'+number.toFixed(2);return number.toFixed(2)+' '+currency;}
 function creditProvider(provider){const row=element('section','usage-provider');row.append(element('h3','',text(provider.label)));const credits=provider.credits||{};if(!credits.available||!Array.isArray(credits.balances)||!credits.balances.length){row.append(element('p','empty',text(credits.reason||'Credit balance is unavailable.')));return row;}const balance=credits.balances[0];row.append(element('div','detail-value',text(formatCredit(balance.remaining,balance.currency))));return row;}
 function githubBucket(label,bucket){const row=element('div','usage-row');const heading=element('div','usage-label');heading.append(element('span','',text(label)),element('span','',text(bucket.remaining+' remaining')));row.append(heading);row.append(element('div','subtle',text(bucket.used+' used / '+bucket.limit+' limit')));const reset=resetText({resetsAt:bucket.reset});if(reset)row.append(element('div','subtle',text(reset)));return row;}
-function githubUsageCard(snapshot,status){const card=element('section','usage-provider');card.append(element('h3','',text('GitHub API')));const resources=snapshot?.resources||{};const bars=element('div','usage-bars');if(resources.core)bars.append(githubBucket('REST core',resources.core));if(resources.graphql)bars.append(githubBucket('GraphQL',resources.graphql));if(resources.search)bars.append(githubBucket('Search',resources.search));if(!bars.children.length)bars.append(element('p','empty',text('GitHub quota telemetry is unavailable.')));if(status?.limited)bars.append(element('div','error-state',text('Relay cooldown active'+(status.cooldownUntil?' until '+new Date(status.cooldownUntil).toLocaleString():''))));else bars.append(element('div','subtle',text('Relay cooldown inactive')));if(status?.calls)bars.append(element('div','subtle',text('Calls since start · GraphQL '+(status.calls.graphql||0)+' · REST '+(status.calls.rest||0)+' · quota '+(status.calls.rateLimit||0))));if(status?.readPaths)bars.append(element('div','subtle',text('Read paths · workspace scans '+(status.readPaths.workspaceScans||0)+' · PR refreshes '+(status.readPaths.prRefreshes||0))));card.append(bars);return card;}
+function githubCounterLine(label,values){const entries=Object.entries(values||{}).sort((a,b)=>Number(b[1])-Number(a[1])).slice(0,8);return entries.length?element('div','subtle',text(label+' · '+entries.map(([key,count])=>key+' '+count).join(' · '))):null;}
+function githubUsageCard(snapshot,status){const card=element('section','usage-provider');card.append(element('h3','',text('GitHub API')));const resources=snapshot?.resources||{};const bars=element('div','usage-bars');if(resources.core)bars.append(githubBucket('REST core',resources.core));if(resources.graphql)bars.append(githubBucket('GraphQL',resources.graphql));if(resources.search)bars.append(githubBucket('Search',resources.search));if(!bars.children.length)bars.append(element('p','empty',text('GitHub quota telemetry is unavailable.')));if(status?.limited)bars.append(element('div','error-state',text('Relay cooldown active'+(status.cooldownUntil?' until '+new Date(status.cooldownUntil).toLocaleString():''))));else bars.append(element('div','subtle',text('Relay cooldown inactive')));if(status?.calls)bars.append(element('div','subtle',text('Calls since start · GraphQL '+(status.calls.graphql||0)+' · REST '+(status.calls.rest||0)+' · quota '+(status.calls.rateLimit||0))));const operations=githubCounterLine('GraphQL operations',status?.graphql?.operations);if(operations)bars.append(operations);const contexts=githubCounterLine('GraphQL contexts',status?.graphql?.contexts);if(contexts)bars.append(contexts);if(status?.readPaths)bars.append(element('div','subtle',text('Read paths · workspace scans '+(status.readPaths.workspaceScans||0)+' · PR refreshes '+(status.readPaths.prRefreshes||0))));card.append(bars);return card;}
 async function drawUsage(){try{const overview=await loadJSON('/api/usage');usageRoot.replaceChildren();usageMeta.textContent='Real account telemetry when available';const providers=Array.isArray(overview.providers)?overview.providers:[];const credits=Array.isArray(overview.credits)?overview.credits:[];const grid=element('div','usage-providers');if(overview.github||overview.githubStatus)grid.append(githubUsageCard(overview.github,overview.githubStatus));for(const provider of providers)grid.append(usageProvider(provider));for(const provider of credits)grid.append(creditProvider(provider));if(!grid.children.length){usageRoot.append(element('p','empty',text('Usage telemetry is unavailable.')));return;}usageRoot.append(grid);}catch(error){usageMeta.textContent='Unavailable';usageRoot.replaceChildren(element('p','error-state',text('Usage unavailable: '+error.message)));}}
 async function drawRules(){rulesStatus.textContent='';try{const rules=await loadJSON('/api/model-router-rules');rulesText.value=typeof rules.text==='string'?rules.text:'';rulesMeta.textContent=rules.hash&&rules.hash!=='none'?'Loaded · '+rules.hash.slice(0,12):'No custom rules saved';}catch(error){rulesMeta.textContent='Unavailable';rulesStatus.textContent='Could not load rules: '+error.message;}}
 async function saveRules(){rulesSave.disabled=true;rulesStatus.textContent='Saving…';try{const response=await fetch('/api/model-router-rules',{method:'PUT',headers:{'content-type':'text/plain; charset=utf-8'},body:rulesText.value});if(!response.ok)throw new Error(response.status+' '+await response.text());const rules=await response.json();rulesMeta.textContent='Saved · '+rules.hash.slice(0,12);rulesStatus.textContent='Saved. New routing decisions will load these rules.';}catch(error){rulesStatus.textContent='Save failed: '+error.message;}finally{rulesSave.disabled=false;}}

package/dist/pool.js

@@ -1,4 +1,4 @@
-import { GitHubStore, listManagedGitHubJobs } from './store.js';
+import { GitHubStore, listManagedGitHubJobs, withGitHubRequestContext } from './store.js';
 import { eventFor } from './events.js';
 const RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
 export function compareJobPriority(a, b) { return RANK[a.priority ?? 'P2'] - RANK[b.priority ?? 'P2'] || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id); }
@@ -28,6 +28,7 @@ export class RepositoryWorkerPool {
     reconcileLocks = new Map();
     targetedReconcileFlights = new Map();
     jobTargets = new Map();
+    targetSeeds = new Map();
     constructor(client, repository, trustedAuthors, concurrency, makeReconciler, isRateLimited = () => false) {
         this.client = client;
         this.trustedAuthors = trustedAuthors;
@@ -60,7 +61,7 @@ export class RepositoryWorkerPool {
         for (const job of terminalManagedJobs(discovered)) {
             await this.reconcileExclusive(job.id, async () => {
                 const store = new GitHubStore(this.client, job.repository, job.prNumber, this.trustedAuthors);
-                await this.makeReconciler(store, 0).reconcile(job.id);
+                await withGitHubRequestContext(this.client, 'pool.terminal-reconcile', () => this.makeReconciler(store, 0).reconcile(job.id));
             });
         }
         const jobs = runnableManagedJobs(discovered);
@@ -75,7 +76,7 @@ export class RepositoryWorkerPool {
                 continue;
             const allowance = Math.max(1, Math.min(capacity, ready || (expiredRunning ? 1 : 0) || 1));
             await this.reconcileExclusive(job.id, async () => {
-                await this.makeReconciler(store, allowance).reconcile(job.id);
+                await withGitHubRequestContext(this.client, 'pool.discovered-reconcile', () => this.makeReconciler(store, allowance).reconcile(job.id));
             });
             capacity -= allowance;
         }
@@ -92,13 +93,18 @@ export class RepositoryWorkerPool {
         try {
             do {
                 this.pending = false;
-                await this.reconcileDiscovered(await aggregateManagedGitHubJobs(this.client, this.repositories, this.trustedAuthors));
+                await this.reconcileDiscovered(await withGitHubRequestContext(this.client, 'pool.workspace-scan', () => aggregateManagedGitHubJobs(this.client, this.repositories, this.trustedAuthors)));
             } while (this.pending);
         }
         finally {
             this.running = false;
         }
     }
+    seedTargetSnapshot(repository, prNumber, jobId, seed) {
+        if (!this.repositories.includes(repository))
+            return;
+        this.targetSeeds.set(`${repository}#${prNumber}:${jobId}`, seed);
+    }
     async reconcileTarget(repository, prNumber, jobId) {
         if (this.isRateLimited() || !this.repositories.includes(repository))
             return;
@@ -108,8 +114,11 @@ export class RepositoryWorkerPool {
         if (existing)
             return existing;
         const flight = this.reconcileExclusive(jobId, async () => {
-            const store = new GitHubStore(this.client, repository, prNumber, this.trustedAuthors);
-            await this.makeReconciler(store, Math.max(1, this.concurrency)).reconcile(jobId);
+            const seedKey = `${repository}#${prNumber}:${jobId}`;
+            const seed = this.targetSeeds.get(seedKey) ?? null;
+            this.targetSeeds.delete(seedKey);
+            const store = new GitHubStore(this.client, repository, prNumber, this.trustedAuthors, seed);
+            await withGitHubRequestContext(this.client, seed ? 'pool.targeted-reconcile.seeded' : 'pool.targeted-reconcile', () => this.makeReconciler(store, Math.max(1, this.concurrency)).reconcile(jobId));
         });
         this.targetedReconcileFlights.set(key, flight);
         try {
@@ -130,9 +139,9 @@ export class RepositoryWorkerPool {
         }
         const store = new GitHubStore(this.client, target.repository, target.prNumber, this.trustedAuthors);
         const reconciler = this.makeReconciler(store, Math.max(1, this.concurrency));
-        await reconciler.handleEvent(event);
+        await withGitHubRequestContext(this.client, `pool.event.${event.type}`, () => reconciler.handleEvent(event));
         if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type))
-            await reconciler.reconcile(event.job_id);
+            await withGitHubRequestContext(this.client, `pool.event-reconcile.${event.type}`, () => reconciler.reconcile(event.job_id));
     }
     async watch(bus) {
         return bus.subscribeAll(async (event) => {

package/dist/relayd.js

@@ -9,7 +9,7 @@ import { serveDashboard } from './dashboard.js';
 import { NatsEventBus } from './events.js';
 import { RepositoryWorkerPool, aggregateManagedGitHubJobs } from './pool.js';
 import { Reconciler } from './reconciler.js';
-import { dashboardManagedJobs, GitHubStore, InMemoryStore, loadManagedGitHubPullRequestGraphql } from './store.js';
+import { dashboardManagedJobs, GitHubStore, InMemoryStore, loadManagedGitHubPullRequestSnapshotGraphql, withGitHubRequestContext } from './store.js';
 import { githubAuthContext } from './github-auth.js';
 import { dashboardJobAction, isEntrypoint, runtimePlanner, runtimeReviewer, startService, SERVICE_DEFAULTS } from './cli.js';
 import { dashboardTaskAction, dashboardTaskSetState } from './dashboard-actions.js';
@@ -119,7 +119,7 @@ export async function runDaemon(argv) {
             return cachedOverviews;
         try {
             githubReadPaths.workspaceScans += 1;
-            const refreshed = await aggregateManagedGitHubJobs(client, scanRepositories, trusted);
+            const refreshed = await withGitHubRequestContext(client, 'relayd.workspace-refresh', () => aggregateManagedGitHubJobs(client, scanRepositories, trusted));
             const scanned = new Set(scanRepositories);
             cachedOverviews = dashboardManagedJobs([...cachedOverviews.filter(item => !scanned.has(item.job.repository)), ...refreshed]);
             try {
@@ -143,21 +143,21 @@ export async function runDaemon(argv) {
         catch { /* cache is best effort */ }
     };
     const pullRequestRefreshFlights = new Map();
-    const refreshPullRequest = async (repository, prNumber) => {
+    const refreshPullRequestSnapshot = async (repository, prNumber) => {
         if (client.rateLimitStatus().limited)
-            return cachedOverviews.filter(item => item.job.repository === repository && item.job.prNumber === prNumber);
+            return { overviews: cachedOverviews.filter(item => item.job.repository === repository && item.job.prNumber === prNumber), seed: { prNode: {}, comments: null } };
         const key = `${repository}#${prNumber}`;
         const existing = pullRequestRefreshFlights.get(key);
         if (existing)
             return existing;
         const flight = (async () => {
             githubReadPaths.prRefreshes += 1;
-            const refreshed = await loadManagedGitHubPullRequestGraphql(client, repository, prNumber, trusted);
+            const snapshot = await withGitHubRequestContext(client, 'relayd.pr-refresh', () => loadManagedGitHubPullRequestSnapshotGraphql(client, repository, prNumber, trusted));
             cachedOverviews = cachedOverviews.filter(item => item.job.repository !== repository || item.job.prNumber !== prNumber);
-            cachedOverviews.push(...refreshed);
+            cachedOverviews.push(...snapshot.overviews);
             cachedOverviews = dashboardManagedJobs(cachedOverviews);
             await persistCache();
-            return refreshed;
+            return snapshot;
         })();
         pullRequestRefreshFlights.set(key, flight);
         try {
@@ -168,6 +168,7 @@ export async function runDaemon(argv) {
                 pullRequestRefreshFlights.delete(key);
         }
     };
+    const refreshPullRequest = async (repository, prNumber) => (await refreshPullRequestSnapshot(repository, prNumber)).overviews;
     const initial = cachedOverviews;
     const fallback = initial[0]?.job;
     const dashboardStore = fallback ? new GitHubStore(client, fallback.repository, fallback.prNumber, trusted) : new InMemoryStore();
@@ -206,8 +207,10 @@ export async function runDaemon(argv) {
         refresh: async (event) => {
             if (!event.repository || !event.pullRequest)
                 return [];
-            const refreshed = await refreshPullRequest(event.repository, event.pullRequest);
-            return refreshed.map(item => item.job.id);
+            const snapshot = await refreshPullRequestSnapshot(event.repository, event.pullRequest);
+            for (const item of snapshot.overviews)
+                pool.seedTargetSnapshot(event.repository, event.pullRequest, item.job.id, snapshot.seed);
+            return snapshot.overviews.map(item => item.job.id);
         },
         wake: async (event) => {
             if (!event.repository || !event.pullRequest)

package/dist/store-github.js

@@ -7,11 +7,21 @@ export class GitHubStore {
     repository;
     prNumber;
     trustedAuthors;
-    constructor(client, repository, prNumber, trustedAuthors = new Set()) {
+    prNodeCache = null;
+    commentsCache = null;
+    commentsFlight = null;
+    clearReadSnapshot() { this.prNodeCache = null; this.commentsCache = null; this.commentsFlight = null; }
+    constructor(client, repository, prNumber, trustedAuthors = new Set(), seed = null) {
         this.client = client;
         this.repository = repository;
         this.prNumber = prNumber;
         this.trustedAuthors = trustedAuthors;
+        if (seed) {
+            if (Object.keys(seed.prNode).length > 0)
+                this.prNodeCache = Promise.resolve(seed.prNode);
+            if (seed.comments)
+                this.commentsCache = [...seed.comments];
+        }
     }
     taskKey(task) { return `${this.repository}#${this.prNumber}:${task.jobId ?? ''}/${task.id}`; }
     taskKeyFromBody(body) { const task = parseTask(body); return task ? this.taskKey(task) : null; }
@@ -49,43 +59,64 @@ export class GitHubStore {
         return await this.client.graphql(query, variables);
     }
     async prNode() {
-        const { owner, name } = this.repoParts();
-        const data = await this.graphql('query($owner:String!,$name:String!,$number:Int!){repository(owner:$owner,name:$name){pullRequest(number:$number){id state merged mergedAt closedAt body headRefName headRefOid}}}', { owner, name, number: this.prNumber });
-        const repository = data.repository;
-        const pr = repository?.pullRequest;
-        if (!pr)
-            throw new Error(`Pull request #${this.prNumber} not found in ${this.repository}`);
-        return pr;
+        if (this.prNodeCache)
+            return this.prNodeCache;
+        const flight = (async () => {
+            const { owner, name } = this.repoParts();
+            const data = await this.graphql('query($owner:String!,$name:String!,$number:Int!){repository(owner:$owner,name:$name){pullRequest(number:$number){id state merged mergedAt closedAt body headRefName headRefOid}}}', { owner, name, number: this.prNumber });
+            const repository = data.repository;
+            const pr = repository?.pullRequest;
+            if (!pr)
+                throw new Error(`Pull request #${this.prNumber} not found in ${this.repository}`);
+            return pr;
+        })();
+        this.prNodeCache = flight;
+        try {
+            return await flight;
+        }
+        catch (error) {
+            if (this.prNodeCache === flight)
+                this.prNodeCache = null;
+            throw error;
+        }
     }
     async pullRequestBody() {
         const pr = await this.prNode();
         return typeof pr.body === 'string' ? pr.body : '';
     }
     async list() {
-        const { owner, name } = this.repoParts();
-        const all = [];
-        let cursor = null;
-        do {
-            const data = await this.graphql('query($owner:String!,$name:String!,$number:Int!,$cursor:String){repository(owner:$owner,name:$name){pullRequest(number:$number){comments(first:100,after:$cursor){nodes{id databaseId url body updatedAt author{login}} pageInfo{hasNextPage endCursor}}}}}', { owner, name, number: this.prNumber, cursor });
-            const repository = data.repository;
-            const pr = repository?.pullRequest;
-            const comments = pr?.comments;
-            const nodes = Array.isArray(comments?.nodes) ? comments.nodes : [];
-            for (const value of nodes) {
-                const author = value.author;
-                all.push({
-                    id: Number(value.databaseId ?? 0),
-                    nodeId: typeof value.id === 'string' ? value.id : undefined,
-                    url: typeof value.url === 'string' ? value.url : undefined,
-                    body: String(value.body ?? ''),
-                    updatedAt: String(value.updatedAt ?? ''),
-                    authorLogin: typeof author?.login === 'string' ? author.login : null
-                });
-            }
-            const pageInfo = comments?.pageInfo;
-            cursor = pageInfo?.hasNextPage === true && typeof pageInfo.endCursor === 'string' ? pageInfo.endCursor : null;
-        } while (cursor);
-        return this.overlayTaskWrites(all);
+        if (this.commentsCache)
+            return this.overlayTaskWrites(this.commentsCache);
+        if (this.commentsFlight)
+            return this.overlayTaskWrites(await this.commentsFlight);
+        const flight = (async () => {
+            const { owner, name } = this.repoParts();
+            const all = [];
+            let cursor = null;
+            do {
+                const data = await this.graphql('query($owner:String!,$name:String!,$number:Int!,$cursor:String){repository(owner:$owner,name:$name){pullRequest(number:$number){comments(first:100,after:$cursor){nodes{id databaseId url body updatedAt author{login}} pageInfo{hasNextPage endCursor}}}}}', { owner, name, number: this.prNumber, cursor });
+                const repository = data.repository;
+                const pr = repository?.pullRequest;
+                const comments = pr?.comments;
+                const nodes = Array.isArray(comments?.nodes) ? comments.nodes : [];
+                for (const value of nodes) {
+                    const author = value.author;
+                    all.push({ id: Number(value.databaseId ?? 0), nodeId: typeof value.id === 'string' ? value.id : undefined, url: typeof value.url === 'string' ? value.url : undefined, body: String(value.body ?? ''), updatedAt: String(value.updatedAt ?? ''), authorLogin: typeof author?.login === 'string' ? author.login : null });
+                }
+                const pageInfo = comments?.pageInfo;
+                cursor = pageInfo?.hasNextPage === true && typeof pageInfo.endCursor === 'string' ? pageInfo.endCursor : null;
+            } while (cursor);
+            return all;
+        })();
+        this.commentsFlight = flight;
+        try {
+            this.commentsCache = await flight;
+            return this.overlayTaskWrites(this.commentsCache);
+        }
+        finally {
+            if (this.commentsFlight === flight)
+                this.commentsFlight = null;
+        }
     }
     async comments() { return this.list(); }
     async pullRequestState() {
@@ -104,12 +135,18 @@ export class GitHubStore {
         });
         if (result.merged !== true)
             throw new Error(typeof result.message === 'string' ? result.message : 'Pull request #' + this.prNumber + ' was not merged');
+        this.prNodeCache = null;
     }
     async closePullRequest() {
         await this.client.request('repos/' + this.repository + '/pulls/' + this.prNumber, { method: 'PATCH', body: JSON.stringify({ state: 'closed' }) });
+        this.prNodeCache = null;
     }
     async updatePullRequestBody(body) {
         await this.client.request('repos/' + this.repository + '/pulls/' + this.prNumber, { method: 'PATCH', body: JSON.stringify({ body }) });
+        if (this.prNodeCache) {
+            const current = await this.prNodeCache;
+            this.prNodeCache = Promise.resolve({ ...current, body });
+        }
     }
     async pullRequestHead() {
         const pr = await this.prNode();
@@ -139,6 +176,7 @@ export class GitHubStore {
         const job = jobs.find(x => x.id === jobId);
         if (!job) {
             const conflicting = bodyJob ?? commentJobs[0];
+            this.clearReadSnapshot();
             if (conflicting)
                 throw new Error(`JOB_ID_MISMATCH: PR #${this.prNumber} is bound to ${conflicting.id}, not ${jobId}`);
             throw new Error(`JOB_MARKER_MISSING: Managed GitHub job ${jobId} has no durable ${JOB_MARKER} marker in PR #${this.prNumber}`);
@@ -188,7 +226,7 @@ export class GitHubStore {
         const data = await this.graphql('mutation($subjectId:ID!,$body:String!){addComment(input:{subjectId:$subjectId,body:$body}){commentEdge{node{id databaseId url body updatedAt author{login}}}}}', { subjectId: pr.id, body });
         const edge = data.addComment?.commentEdge;
         const node = edge?.node;
-        return {
+        const persisted = {
             id: Number(node?.databaseId ?? 0),
             nodeId: typeof node?.id === 'string' ? node.id : undefined,
             url: typeof node?.url === 'string' ? node.url : undefined,
@@ -196,13 +234,16 @@ export class GitHubStore {
             updatedAt: typeof node?.updatedAt === 'string' ? node.updatedAt : new Date().toISOString(),
             authorLogin: typeof node?.author?.login === 'string' ? String((node?.author).login) : [...this.trustedAuthors][0] ?? null,
         };
+        if (this.commentsCache)
+            this.commentsCache.push(persisted);
+        return persisted;
     }
     async updateComment(comment, body) {
         if (!comment.nodeId)
             throw new Error('GitHub comment node id is required for GraphQL update');
         const data = await this.graphql('mutation($id:ID!,$body:String!){updateIssueComment(input:{id:$id,body:$body}){issueComment{id databaseId url body updatedAt author{login}}}}', { id: comment.nodeId, body });
         const node = data.updateIssueComment?.issueComment;
-        return {
+        const persisted = {
             id: Number(node?.databaseId ?? comment.id),
             nodeId: typeof node?.id === 'string' ? node.id : comment.nodeId,
             url: typeof node?.url === 'string' ? node.url : comment.url,
@@ -210,11 +251,19 @@ export class GitHubStore {
             updatedAt: typeof node?.updatedAt === 'string' ? node.updatedAt : new Date().toISOString(),
             authorLogin: typeof node?.author?.login === 'string' ? String((node?.author).login) : comment.authorLogin,
         };
+        if (this.commentsCache) {
+            const index = this.commentsCache.findIndex(item => item.nodeId === comment.nodeId || (item.id > 0 && item.id === comment.id));
+            if (index >= 0)
+                this.commentsCache[index] = persisted;
+        }
+        return persisted;
     }
     async deleteComment(comment) {
         if (!comment.nodeId)
             throw new Error('GitHub comment node id is required for GraphQL delete');
         await this.graphql('mutation($id:ID!){deleteIssueComment(input:{id:$id}){clientMutationId}}', { id: comment.nodeId });
+        if (this.commentsCache)
+            this.commentsCache = this.commentsCache.filter(item => item.nodeId !== comment.nodeId && !(item.id > 0 && item.id === comment.id));
     }
     async saveJob(job) {
         const currentBody = await this.pullRequestBody();

package/dist/store.js

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { createSign } from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { parseAgent, parseJob, parseTask, renderAgentComment, renderJobComment, renderTaskComment, AGENT_MARKER, JOB_MARKER, TASK_MARKER } from './markers.js';
 import { isTaskForJob, sameTaskDefinition } from './store-task-definition.js';
 import { parsePackagePublicationMarker } from './github-webhook.js';
@@ -11,28 +12,39 @@ function publicationFromComments(rows, trustedAuthors) {
     });
     return allowed.map(item => parsePackagePublicationMarker(String(item.body ?? ''))).filter((item) => item !== null).at(-1) ?? null;
 }
-export async function loadManagedGitHubPullRequestGraphql(client, repository, prNumber, trustedAuthors) {
+export async function loadManagedGitHubPullRequestSnapshotGraphql(client, repository, prNumber, trustedAuthors) {
     const [owner, name] = repository.split('/', 2);
     if (!owner || !name || !Number.isInteger(prNumber) || prNumber <= 0 || !client.graphql)
-        return [];
-    const query = 'query($owner:String!,$name:String!,$number:Int!){repository(owner:$owner,name:$name){pullRequest(number:$number){state isDraft merged mergedAt closedAt body comments(last:100){nodes{databaseId url author{login} body}}}}}';
+        return { overviews: [], seed: { prNode: {}, comments: null } };
+    const query = 'query($owner:String!,$name:String!,$number:Int!){repository(owner:$owner,name:$name){pullRequest(number:$number){id state isDraft merged mergedAt closedAt body headRefName headRefOid comments(last:100){totalCount nodes{id databaseId url updatedAt author{login} body}}}}}';
     const data = await client.graphql(query, { owner, name, number: prNumber });
     const repo = data.repository;
     const pr = repo?.pullRequest;
     if (!pr)
-        return [];
-    const comments = pr.comments?.nodes;
-    const trusted = (Array.isArray(comments) ? comments : []).filter(item => {
-        const row = item;
+        return { overviews: [], seed: { prNode: {}, comments: null } };
+    const commentConnection = pr.comments;
+    const commentRows = (Array.isArray(commentConnection?.nodes) ? commentConnection.nodes : []);
+    const totalCount = Number(commentConnection?.totalCount ?? commentRows.length);
+    const seedComments = Number.isFinite(totalCount) && totalCount <= commentRows.length ? commentRows.map(row => {
         const author = row.author;
+        return {
+            id: Number(row.databaseId ?? 0),
+            nodeId: typeof row.id === 'string' ? row.id : undefined,
+            url: typeof row.url === 'string' ? row.url : undefined,
+            body: String(row.body ?? ''),
+            updatedAt: String(row.updatedAt ?? ''),
+            authorLogin: typeof author?.login === 'string' ? author.login : null,
+        };
+    }) : null;
+    const trusted = commentRows.filter(item => {
+        const author = item.author;
         return typeof author?.login === 'string' && trustedAuthors.has(author.login);
     });
     const bodyJob = parseJob(typeof pr.body === 'string' ? pr.body : '');
     const commentJobs = trusted.map(item => parseJob(String(item.body ?? ''))).filter((item) => item !== null);
     const jobs = bodyJob ? [bodyJob] : commentJobs;
-    const publication = publicationFromComments((Array.isArray(comments) ? comments : []), trustedAuthors);
-    const tasks = trusted.map(item => {
-        const row = item;
+    const publication = publicationFromComments(commentRows, trustedAuthors);
+    const tasks = trusted.map(row => {
         const task = parseTask(String(row.body ?? ''));
         if (!task)
             return null;
@@ -41,12 +53,18 @@ export async function loadManagedGitHubPullRequestGraphql(client, repository, pr
     }).filter((item) => item !== null);
     const state = String(pr.state ?? '').toUpperCase();
     const githubState = pr.merged === true ? 'MERGED' : state === 'CLOSED' ? 'CLOSED' : 'OPEN';
-    return jobs.map(job => {
+    const overviews = jobs.map(job => {
         job.tasks = tasks.filter(task => task.jobId === job.id || (!task.jobId && jobs.length === 1));
         if (!job.description && typeof pr.body === 'string' && pr.body)
             job.description = pr.body;
+        if (typeof pr.headRefOid === 'string' && pr.headRefOid)
+            job.headSha = pr.headRefOid;
         return { job, githubState, draft: pr.isDraft === true, mergedAt: typeof pr.mergedAt === 'string' ? pr.mergedAt : null, closedAt: typeof pr.closedAt === 'string' ? pr.closedAt : null, publication };
     });
+    return { overviews, seed: { prNode: pr, comments: seedComments } };
+}
+export async function loadManagedGitHubPullRequestGraphql(client, repository, prNumber, trustedAuthors) {
+    return (await loadManagedGitHubPullRequestSnapshotGraphql(client, repository, prNumber, trustedAuthors)).overviews;
 }
 export async function loadManagedGitHubJobGraphql(client, repository, prNumber, jobId, trustedAuthors) {
     return (await loadManagedGitHubPullRequestGraphql(client, repository, prNumber, trustedAuthors)).find(item => item.job.id === jobId) ?? null;
@@ -97,6 +115,7 @@ export class InMemoryStore {
         return [...this.values.values()].map(parseTask).filter((x) => x !== null).filter(task => isTaskForJob(task, jobId, jobs.length === 1));
     }
 }
+export async function withGitHubRequestContext(client, context, work) { return client.withRequestContext ? client.withRequestContext(context, work) : work(); }
 async function githubGraphql(client, query, variables) {
     if (!client.graphql)
         throw new Error('GitHub GraphQL client is required');
@@ -248,12 +267,36 @@ export class GhApiClient {
     rateLimitFlight = null;
     rateLimitCacheTtlMs = 5 * 60_000;
     apiDiagnostics = { rest: 0, graphql: 0, rateLimit: 0 };
+    graphqlDiagnostics = { operations: {}, contexts: {} };
+    requestContext = new AsyncLocalStorage();
     constructor(appAuth = null) {
         this.appAuth = appAuth;
     }
+    async withRequestContext(context, work) { return await this.requestContext.run(context, work); }
+    graphqlOperation(query) {
+        if (/mutation\s*\([^)]*\)\s*\{addComment\(/.test(query))
+            return 'comment.add';
+        if (/updateIssueComment\(/.test(query))
+            return 'comment.update';
+        if (/deleteIssueComment\(/.test(query))
+            return 'comment.delete';
+        if (/viewer\s*\{login/.test(query))
+            return 'viewer.login';
+        if (/comments\(first:100,after:\$cursor\)/.test(query))
+            return 'pr.comments';
+        if (/comments\(last:100\)/.test(query))
+            return 'pr.snapshot';
+        if (/headRefName/.test(query) && /headRefOid/.test(query))
+            return 'pr.node';
+        if (/repository\(owner:\$owner,name:\$name\)\{id\}/.test(query))
+            return 'repository.id';
+        if (/pullRequests\(/.test(query))
+            return 'repository.pull-requests';
+        return /^\s*mutation/.test(query) ? 'mutation.other' : 'query.other';
+    }
     rateLimitStatus() {
         const limited = Date.now() < this.cooldownUntil;
-        return { limited, cooldownUntil: limited ? new Date(this.cooldownUntil).toISOString() : null, calls: { ...this.apiDiagnostics } };
+        return { limited, cooldownUntil: limited ? new Date(this.cooldownUntil).toISOString() : null, calls: { ...this.apiDiagnostics }, graphql: { operations: { ...this.graphqlDiagnostics.operations }, contexts: { ...this.graphqlDiagnostics.contexts } } };
     }
     async rateLimitSnapshot(force = false) {
         const now = Date.now();
@@ -368,6 +411,10 @@ export class GhApiClient {
     async graphql(query, variables = {}) {
         this.assertAvailable();
         this.apiDiagnostics.graphql += 1;
+        const operation = this.graphqlOperation(query);
+        const context = this.requestContext.getStore() ?? 'unscoped';
+        this.graphqlDiagnostics.operations[operation] = (this.graphqlDiagnostics.operations[operation] ?? 0) + 1;
+        this.graphqlDiagnostics.contexts[context] = (this.graphqlDiagnostics.contexts[context] ?? 0) + 1;
         const payload = JSON.stringify({ query, variables });
         const stdout = await this.spawnGh(['api', 'graphql', '--input', '-'], payload, await this.commandEnv());
         const parsed = JSON.parse(stdout);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "1.0.137",
+  "version": "1.0.139",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {