agents-relay 2.0.5 → 2.0.7

package/README.md

@@ -4,6 +4,44 @@ Agents Relay is a generic TypeScript runtime for durable asynchronous agent jobs
 
 V2 separates **operational execution state** from that collaboration record. A local RelayStore may use SQLite/WAL for runtime snapshots, event idempotency and a durable GitHub projection outbox. ProjectedDurableStore bootstraps from the existing GitHub representation, commits Job/Plan/Task runtime changes locally, and lets GitHubProjectionWriter project them asynchronously. GitHub therefore remains the human-readable durable Job/Plan/Task/Review surface without being required for every high-frequency runtime transition.
 
+## V2 architecture
+
+```mermaid
+flowchart LR
+    Human[Human / orchestrator] --> GH[GitHub PR + comments<br/>collaboration + audit surface]
+    GH --> Inbound[Typed inbound GitHub facts]
+    Worker[Workers / adapters] --> Events[Event Bus<br/>lifecycle + progress facts]
+    Inbound --> Coord[ReconcileCoordinator]
+    Events --> Coord
+    Coord --> Graphs[Executable Mermaid graphs<br/>workflow authority]
+    Graphs --> Runtime[TypeScript primitives<br/>facts + guards + effects]
+    Runtime --> Store[(SQLite/WAL RelayStore<br/>operational execution truth)]
+    Store --> Outbox[Projection outbox]
+    Outbox --> Writer[GitHubProjectionWriter]
+    Writer --> GH
+    Store --> Views[Dashboard / scheduler / recovery]
+```
+
+RelayStore owns local operational execution facts; GitHub remains the human-readable collaboration and audit projection. Worker events are authoritative lifecycle inputs for model-backed tasks, but they are not a separate durable database. The graph engine owns workflow branching; TypeScript owns facts, persistence, locking/claims, I/O, and primitive guard/action implementations.
+
+### Workflow graph navigation
+
+| Area | Canonical graph |
+| --- | --- |
+| Job lifecycle | [`workflow/job-lifecycle-v2.mmd`](workflow/job-lifecycle-v2.mmd) |
+| Task lifecycle | [`workflow/task-lifecycle-v2.mmd`](workflow/task-lifecycle-v2.mmd) |
+| Review lifecycle | [`workflow/review-lifecycle-v2.mmd`](workflow/review-lifecycle-v2.mmd) |
+| Planner trigger | [`workflow/planner-trigger-v2.mmd`](workflow/planner-trigger-v2.mmd) |
+| Planner orchestration | [`workflow/planner-orchestration-v2.mmd`](workflow/planner-orchestration-v2.mmd) |
+| Blocker resolution | [`workflow/blocker-resolution-v2.mmd`](workflow/blocker-resolution-v2.mmd) |
+| Authoritative unblock | [`workflow/authoritative-unblock-v2.mmd`](workflow/authoritative-unblock-v2.mmd) |
+| Scheduled run | [`workflow/scheduled-run-v2.mmd`](workflow/scheduled-run-v2.mmd) |
+| Schedule cycle | [`workflow/schedule-cycle-v2.mmd`](workflow/schedule-cycle-v2.mmd) |
+| Troubleshooter | [`workflow/troubleshooter-v2.mmd`](workflow/troubleshooter-v2.mmd) |
+| Related-task action policy | [`workflow/task-related-action-v2.mmd`](workflow/task-related-action-v2.mmd) |
+
+Legacy [`workflow/job-lifecycle.mmd`](workflow/job-lifecycle.mmd) and [`workflow/task-lifecycle.mmd`](workflow/task-lifecycle.mmd) are compatibility/parity fixtures only. See [`docs/workflow-engine.md`](docs/workflow-engine.md) and [`docs/architecture-v2.md`](docs/architecture-v2.md).
+
 ## Quick start
 
 For GitHub-backed work, create or adopt the PR through Agents Relay itself. This guarantees the durable job marker exists before any managed task is submitted.
@@ -50,7 +88,7 @@ npx agents-relay task update --repo OWNER/REPO --pr 12 --id job-1 --task-id chil
 
 Jobs separate durable lifecycle from derived runtime status. Durable lifecycle is `DRAFT | ACTIVE | COMPLETED | CANCELLED`: a newly created unscheduled Job is DRAFT, creating executable work activates it, and scheduled Jobs are ACTIVE because the scheduler is allowed to advance them. Runtime status (`IDLE`, `WAITING`, `QUEUED`, `RUNNING`, `BLOCKED`, `FAILED`, `REVIEWING`, `MERGE_PENDING`, `MERGED`, or `CANCELLED`) is computed from Tasks, Review, PR, and schedule facts and is never persisted as lifecycle truth.
 
-Lifecycle transition authority lives in the directly renderable v2 flowchart sources [`workflow/job-lifecycle-v2.mmd`](workflow/job-lifecycle-v2.mmd) and [`workflow/task-lifecycle-v2.mmd`](workflow/task-lifecycle-v2.mmd). The legacy `stateDiagram-v2` files remain compatibility fixtures only; see [`docs/workflow-engine.md`](docs/workflow-engine.md) for the executable Mermaid profile and runtime boundary.
+Lifecycle transition authority lives in the directly renderable V2 flowchart sources linked in [Workflow graph navigation](#workflow-graph-navigation). The legacy `stateDiagram-v2` files remain compatibility fixtures only; see [`docs/workflow-engine.md`](docs/workflow-engine.md) for the executable Mermaid profile and runtime boundary.
 
 The canonical Mermaid Graph Engine is the authoritative durable workflow decision path. Job/Task lifecycle transitions plus Review, Planner, Blocker/Unblock, Schedule, and Troubleshooter orchestration branches are defined by the v2 workflow graphs and executed through the shared graph runtime. TypeScript supplies facts and primitive action/effect implementations; it must not duplicate those workflow branches as a second procedural state machine.
 
@@ -86,10 +124,7 @@ Task producers must follow `skills/agents-relay/contracts/task-job-contract.md`;
 Execution routing is code-driven: Relay builds complete executable worker+model routes from authoritative runtime/model/resource facts, removes only impossible routes, then calls the generic typed `decide(request, contract)` boundary once. Free-text routing guidance and task/resource/capability signals are soft decision facts; decision failure falls back deterministically to a usable Codex default route. See [Execution Router and typed decisions](docs/worker-model-routers.md).
 All task producers use the same story-size contract: `S`≈5 minutes, `M`≈15 minutes, and `L`≈45 minutes of normal-reasoning execution, with `M` as the default. `high` reasoning doubles that overall window. ChatGPT Browser Worker start-ack timeout is derived as one third of the effective overall timeout, clamped between 1 and 5 minutes. Orchestrators and planners should choose `storySize`, not raw timeout milliseconds; `--timeout` remains only as an explicit compatibility/debug override.
 
-Autonomous jobs can also be scheduled without a Relay database. The job marker
-stores a five-field cron expression, IANA timezone, next run, and missed-run /
-concurrency policy; GitHub issue labels provide the indexed discovery surface.
-A repository heartbeat invokes `tick` at 10-minute resolution. See
+Autonomous jobs can also be scheduled. The Job marker stores a five-field cron expression, IANA timezone, next run, and missed-run/concurrency policy. The daemon evaluates the SQLite-backed managed Job view and validates durable schedule facts before claiming a due slot. A repository heartbeat invokes `tick` at 10-minute resolution. See
 [Scheduled autonomous jobs](docs/scheduled-autonomous-jobs.md) for the exact
 operational contract.
 
@@ -152,7 +187,7 @@ This small live suite covers two Temporary Chat submission gates: a normal text
 prompt and a prompt with an attachment. It does not exercise worker lifecycle
 events, durable-thread reuse, resume, or retry behavior.
 
-Open the dashboard on localhost port 8787. The marker format is intentionally public and append-friendly; the CLI uses GitHubStore with the authenticated gh client in operational mode.
+Open the dashboard on localhost port 8787. The marker format is intentionally public and append-friendly. Daemon/workspace operation uses `ProjectedDurableStore` over SQLite RelayStore plus the authenticated GitHub projection adapter; GitHubStore is not the daemon operational state database.
 
 External product feedback uses the reusable `src/feedback.ts` contract. See [docs/feedback-intake.md](docs/feedback-intake.md) for the schema, attachment limits, privacy rules, materialization path, and provenance envelope for later Jobs/Tasks/PRs.
 
@@ -162,7 +197,7 @@ reconcile leases and launches ready tasks without waiting inside the runtime sch
 
 For automation, Agents Relay can use GitHub App installation authentication via `AGENTS_RELAY_GITHUB_APP_ID`, `AGENTS_RELAY_GITHUB_APP_INSTALLATION_ID`, and `AGENTS_RELAY_GITHUB_APP_PRIVATE_KEY_FILE` (or matching CLI flags). Webhook mode is local-first: targeted webhook reconciliation is primary, dashboard auto-refresh reads the disposable in-process view restored from SQLite RelayStore state, and the broad watchdog drops to a 30-minute fallback. No separate persisted dashboard Job cache is maintained. See [docs/github-app-rate-limit.md](docs/github-app-rate-limit.md).
 
-V1 assumes one active runner/daemon per job. Use a distributed atomic lease before running multiple reconcilers. Do not put secrets, credentials, private prompts, or large private payloads in the PR-body Job marker or PR-comment Task markers; store only summaries and artifact references.
+Run one logical reconciliation authority per Job. `ReconcileCoordinator` serializes in-process work; use a distributed atomic lease before multiple independent reconcilers own the same Job. Do not put secrets, credentials, private prompts, or large private payloads in the PR-body Job marker or PR-comment Task markers; store only summaries and artifact references.
 
 Model-backed tasks are routed by Relay before launch. Normal task producers omit adapter/provider/model; explicit routing flags remain compatibility/debug constraints. See [docs/architecture.md](docs/architecture.md) and [skills/agents-relay/SKILL.md](skills/agents-relay/SKILL.md).
 
@@ -182,7 +217,7 @@ Managed tasks are descriptive work for agents, not shell commands. Use `codex` o
 
 Every model-backed task declares a durable output with `--output task-pr` or `--output file --output-path PATH`. Agents Relay bootstraps workers with the managed PR URL, durable task-comment URL, job/task identity, project, output contract, and mandatory terminal-event contract; workers retrieve the task intent from GitHub rather than receiving a duplicate copy of the stored task prompt.
 
-For Codex and ChatGPT, **events are authoritative task state**. Event publication uses the canonical Neo `events-bus` surface (`events__publish` for sandboxed/hosted workers, or `NEO_EVENTS_EMIT` for direct local workers); Agents Relay only subscribes and reconciles. Relay publishes `task.process.launched` only after successful adapter launch; `task.started` is worker-owned and must be a new, correlated start acknowledgement. Codex publishes `task.process.exited` when its synchronous runtime exits, while ChatGPT publishes `task.process.async_exited` after its submission runtime exits; neither substitutes for `task.completed`, `task.failed`, `task.blocked`, or `task.cancelled`. The ChatGPT worker-owned tab follows the configured close policy: `after-start` waits for the correlated start acknowledgement, `never` keeps it open for debug, and `after-terminal` waits for a new exact-task terminal event; start-ack failure closes only the owned tab after 60 seconds. The executing agent must publish exactly one correlated terminal event. Relay persists the matching durable state only from that terminal event. Model-backed tasks require an event bus and time out explicitly if no terminal event arrives.
+For Codex and ChatGPT, **correlated worker events are authoritative lifecycle inputs**, not a separate durable store. Event publication uses the canonical Neo `events-bus` surface (`events__publish` for sandboxed/hosted workers, or `NEO_EVENTS_EMIT` for direct local workers); Agents Relay subscribes, validates correlation, applies graph transitions, persists results in RelayStore, and projects them to GitHub. Relay publishes `task.process.launched` only after successful adapter launch; `task.started` is worker-owned and must be a new, correlated start acknowledgement. Codex publishes `task.process.exited` when its synchronous runtime exits, while ChatGPT publishes `task.process.async_exited` after its submission runtime exits; neither substitutes for `task.completed`, `task.failed`, `task.blocked`, or `task.cancelled`. The ChatGPT worker-owned tab follows the configured close policy: `after-start` waits for the correlated start acknowledgement, `never` keeps it open for debug, and `after-terminal` waits for a new exact-task terminal event; start-ack failure closes only the owned tab after 60 seconds. The executing agent must publish exactly one correlated terminal event. Relay persists the matching durable state only from that terminal event. Model-backed tasks require an event bus and time out explicitly if no terminal event arrives.
 
 The ChatGPT adapter uses the `chatgpt-browser-worker` path selected by the shared execution-context resolver; Relay does not bundle its own copy. The resolver applies project-local > Neo shared > global `~/.agents` precedence at execution time, so durable tasks store names/intent rather than stale absolute skill paths. It opens a fresh Temporary Chat tab, uses the account defaults, submits the prompt, verifies acceptance, and applies `--chatgpt-tab-close-policy` (or `AGENTS_RELAY_CHATGPT_TAB_CLOSE_POLICY`): `after-start` by default, `never` for test/debug, or `after-terminal` after a new exact-task terminal event. It never closes a user tab and does not poll for the assistant response, resume/reopen a thread, or use conversation text as the result channel. Any observed ChatGPT thread ID is diagnostic only.
 

package/dist/dashboard-html.js

@@ -395,64 +395,19 @@ function creditProvider(provider){const row=element('section','usage-provider');
 function shortReset(reset){if(!Number.isFinite(reset))return '';const at=new Date(reset*1000);const minutes=Math.max(0,Math.ceil((at.getTime()-Date.now())/60000));const relative=minutes<60?minutes+'m':minutes<1440?Math.floor(minutes/60)+'h '+minutes%60+'m':Math.floor(minutes/1440)+'d '+Math.floor((minutes%1440)/60)+'h';return 'Reset '+relative;}
 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+' / '+bucket.limit)));const percent=bucket.limit>0?Math.max(0,Math.min(100,100*bucket.remaining/bucket.limit)):0;const track=element('div','usage-track');track.setAttribute('role','progressbar');track.setAttribute('aria-label',label+' remaining');track.setAttribute('aria-valuemin','0');track.setAttribute('aria-valuemax','100');track.setAttribute('aria-valuenow',String(Math.round(percent)));const fill=element('div','usage-fill');fill.style.width=percent+'%';track.append(fill);row.append(heading,track);const reset=shortReset(bucket.reset);if(reset){const hint=element('div','subtle',text(reset));hint.title=new Date(bucket.reset*1000).toLocaleString();row.append(hint);}return row;}
 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 githubObserved(label,observed){
-  if(!observed)return null;
-  if(Number.isFinite(observed.limit)&&Number.isFinite(observed.remaining)){const row=githubBucket(label,observed);if(observed.reason)row.title=observed.reason;return row;}
-  const state=observed.throttled?'Throttled':observed.available===true?'Available':observed.available===false?'Unavailable':'Unknown';
-  const parts=[label+' observed',state];
-  if(observed.status!==null)parts.push('status '+observed.status);
-  if(observed.retryAfterSeconds!==null)parts.push('retry '+observed.retryAfterSeconds+'s');
-  const row=element('div',observed.throttled?'usage-row error-state':'usage-row subtle');
-  row.textContent=parts.filter(Boolean).join(' · ');
-  if(observed.reason)row.title=observed.reason;
-  return row;
-}
-function githubSecondary(status){
-  const rejection=status?.runtimeRateUsage?.rejection;
-  const row=element('div','usage-row');
-  const heading=element('div','usage-label');
-  if(rejection?.kind!=='secondary'){heading.append(element('span','',text('Secondary protection')),element('span','',text('No active cooldown')));row.append(heading);return row;}
-  const start=Date.parse(rejection.observedAt);
-  const until=Date.parse(rejection.cooldownUntil||status?.cooldownUntil||'');
-  if(!Number.isFinite(start)||!Number.isFinite(until)||until<=start){heading.append(element('span','',text('Secondary protection')),element('span','',text('Throttled')));row.classList.add('error-state');row.append(heading);return row;}
-  const total=until-start;
-  const remaining=Math.max(0,until-Date.now());
-  const percent=Math.max(0,Math.min(100,100*remaining/total));
-  heading.append(element('span','',text('Secondary cooldown')),element('span','',text(Math.ceil(remaining/1000)+'s')));
-  const track=element('div','usage-track');track.setAttribute('role','progressbar');track.setAttribute('aria-label','Secondary cooldown remaining');track.setAttribute('aria-valuemin','0');track.setAttribute('aria-valuemax','100');track.setAttribute('aria-valuenow',String(Math.round(percent)));const fill=element('div','usage-fill');fill.style.width=percent+'%';track.append(fill);
-  const hint=element('div','subtle',text('Retry '+new Date(until).toLocaleString()));hint.title=new Date(until).toLocaleString();
-  row.append(heading,track,hint);
-  return row;
-}
 function githubDiagnostics(status){const body=element('div','usage-details-body');if(status?.calls)body.append(element('div','subtle',text('Calls · 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)body.append(operations);const contexts=githubCounterLine('GraphQL contexts',status?.graphql?.contexts);if(contexts)body.append(contexts);if(status?.readPaths){body.append(element('div','subtle',text('Reads · scans '+(status.readPaths.workspaceScans||0)+' · PR '+(status.readPaths.prRefreshes||0)+' · coalesced '+(status.readPaths.prRefreshCoalesced||0))));const triggers=githubCounterLine('Refresh triggers',status.readPaths.prRefreshesByTrigger);if(triggers)body.append(triggers);const coalesced=githubCounterLine('Coalesced',status.readPaths.prRefreshCoalescedByTrigger);if(coalesced)body.append(coalesced);}if(!body.children.length)return null;const details=element('details','usage-details');details.append(element('summary','',text('Diagnostics')),body);return details;}
-function githubUsageCard(snapshot,status){
+function githubUsageCard(effective,status){
   const card=element('section','usage-provider');
   card.append(element('h3','',text('GitHub API')));
-  const resources=snapshot?.resources||{};
-  const observed=status?.runtimeRateUsage?.resources||{};
   const bars=element('div','usage-bars');
-  bars.append(githubSecondary(status),element('div','usage-label',text('Request-time X-RateLimit headers')));
-  let observedCount=0;
-  for(const row of [githubObserved('REST',observed.core),githubObserved('GraphQL',observed.graphql),githubObserved('Search',observed.search)])if(row){bars.append(row);observedCount++;}
-  if(!observedCount)bars.append(element('p','empty',text('No request-time headers observed')));
-  bars.append(element('div','usage-label',text('Primary quota (/rate_limit)')));
-  let quotaCount=0;
-  for(const pair of [['REST',resources.core],['GraphQL',resources.graphql],['Search',resources.search]])if(pair[1]){bars.append(githubBucket(pair[0],pair[1]));quotaCount++;}
-  if(!quotaCount)bars.append(element('p','empty',text('Quota unavailable')));
-  if(status?.runtimeRateUsage?.rejection&&status.runtimeRateUsage.rejection.kind!=='secondary'){
-    const rejection=status.runtimeRateUsage.rejection;
-    bars.append(element('div','error-state',text('Throttled · '+(rejection.kind==='unknown'?'rate limit':rejection.kind)+' limit')));
-  }
-  if(status?.limited&&status?.runtimeRateUsage?.rejection?.kind!=='secondary'){
-    const until=status.cooldownUntil?' until '+new Date(status.cooldownUntil).toLocaleTimeString():'';
-    bars.append(element('div','error-state',text('Cooldown active'+until)));
-  }
+  if(effective)bars.append(githubBucket('Available',effective));
+  else bars.append(element('p','empty',text('Quota unavailable')));
   const diagnostics=githubDiagnostics(status);
   if(diagnostics)bars.append(diagnostics);
   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 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.githubEffective||overview.githubStatus)grid.append(githubUsageCard(overview.githubEffective,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/execution-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/execution-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;}}
 async function drawShortcuts(){shortcutsStatus.textContent='';shortcutsText.value=chatShortcutText();}

package/dist/dashboard.js

@@ -10,6 +10,13 @@ import { summarizeRuntime } from './runtime-summary.js';
 const GITHUB_REPOSITORY_PATTERN = /^([A-Za-z0-9](?:[A-Za-z0-9-]{0,36}[A-Za-z0-9])?)\/([A-Za-z0-9._-]{1,100})$/;
 const SSE_HEARTBEAT_MS = 15000;
 const EVENTS_HISTORY_FILE = process.env.EVENTS_BUS_DATA_DIR ? join(process.env.EVENTS_BUS_DATA_DIR, 'events.jsonl') : join(homedir(), 'Library', 'Application Support', 'EventsBus', 'events.jsonl');
+function effectiveGitHubUsage(snapshot, runtime) {
+    const candidates = [snapshot?.resources.core, snapshot?.resources.graphql, snapshot?.resources.search, runtime?.resources.core, runtime?.resources.graphql, runtime?.resources.search]
+        .filter((candidate) => candidate !== undefined && candidate !== null)
+        .filter(candidate => Number.isFinite(candidate.limit) && Number(candidate.limit) > 0 && Number.isFinite(candidate.remaining) && Number.isFinite(candidate.reset));
+    const lowest = candidates.reduce((current, candidate) => !current || Number(candidate.remaining) / Number(candidate.limit) < Number(current.remaining) / Number(current.limit) ? candidate : current, null);
+    return lowest ? { limit: Number(lowest.limit), remaining: Number(lowest.remaining), reset: Number(lowest.reset) } : null;
+}
 function isPositiveInteger(candidate) {
     return typeof candidate === 'number' && Number.isInteger(candidate) && candidate > 0;
 }
@@ -149,7 +156,9 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             }
             catch { /* quota telemetry is best-effort during GitHub degradation */ }
         }
-        return JSON.stringify({ ...account, github, githubStatus });
+        const runtime = (githubStatus.runtimeRateUsage ?? null);
+        const githubEffective = effectiveGitHubUsage(github, runtime);
+        return JSON.stringify({ ...account, githubEffective, githubStatus });
     };
     const server = createServer(async (req, res) => {
         if (req.url === '/') {
@@ -192,13 +201,7 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             res.writeHead(202);
             res.end('Accepted');
             queueMicrotask(() => {
-                const refreshDashboard = webhook.refresh
-                    ? webhook.refresh(event)
-                        .then(jobIds => broadcastSnapshots(jobIds))
-                        .catch(error => process.stderr.write(`warning: webhook dashboard snapshot unavailable: ${error instanceof Error ? error.message : String(error)}\n`))
-                    : Promise.resolve();
-                void refreshDashboard
-                    .then(() => webhook.wake(event))
+                void Promise.resolve(webhook.wake(event))
                     .catch(error => process.stderr.write(`warning: webhook wake unavailable: ${error instanceof Error ? error.message : String(error)}\n`));
             });
             return;

package/dist/github-webhook.js

@@ -1,6 +1,5 @@
 import { createHmac, timingSafeEqual } from 'node:crypto';
 export const PACKAGE_PUBLISHED_MARKER = 'agents-relay:package-published:v1';
-const WAKE_EVENTS = new Set(['pull_request', 'issue_comment', 'pull_request_review', 'pull_request_review_comment', 'check_run', 'check_suite', 'workflow_run']);
 export function parsePackagePublicationMarker(body) {
     if (typeof body !== 'string')
         return null;
@@ -34,10 +33,25 @@ export function verifyGitHubWebhook(secret, body, signature) {
     const actual = Buffer.from(signature);
     return expected.length === actual.length && timingSafeEqual(expected, actual);
 }
+function pullRequestFacts(payload, action) {
+    if (action !== 'synchronize' && action !== 'closed')
+        return null;
+    const pr = payload.pull_request;
+    if (!pr)
+        return null;
+    const head = pr.head;
+    const ref = typeof head?.ref === 'string' ? head.ref : null;
+    const sha = typeof head?.sha === 'string' ? head.sha : null;
+    if (!ref || !sha)
+        return null;
+    if (action === 'closed')
+        return { state: pr.merged === true ? 'MERGED' : 'CLOSED', head: { ref, sha } };
+    return { state: 'OPEN', head: { ref, sha } };
+}
 export function parseGitHubWebhook(headers, body) {
     const deliveryId = String(headers['x-github-delivery'] ?? '');
     const event = String(headers['x-github-event'] ?? '');
-    if (!deliveryId || !WAKE_EVENTS.has(event))
+    if (!deliveryId || (event !== 'pull_request' && event !== 'issue_comment'))
         return null;
     let payload;
     try {
@@ -47,19 +61,24 @@ export function parseGitHubWebhook(headers, body) {
         return null;
     }
     const repository = payload.repository;
-    const pullRequest = payload.pull_request;
+    const repositoryName = typeof repository?.full_name === 'string' ? repository.full_name : null;
+    const action = typeof payload.action === 'string' ? payload.action : null;
+    const pr = payload.pull_request;
     const issue = payload.issue;
-    const number = Number(pullRequest?.number ?? (issue?.pull_request ? issue.number : 0));
-    const comment = payload.comment;
-    const publication = event === 'issue_comment' ? parsePackagePublicationMarker(comment?.body) : null;
-    return {
-        deliveryId,
-        event,
-        action: typeof payload.action === 'string' ? payload.action : null,
-        repository: typeof repository?.full_name === 'string' ? repository.full_name : null,
-        pullRequest: Number.isInteger(number) && number > 0 ? number : null,
-        publication,
-    };
+    const number = Number(pr?.number ?? (issue?.pull_request ? issue.number : 0));
+    if (!repositoryName || !Number.isInteger(number) || number <= 0)
+        return null;
+    if (event === 'issue_comment') {
+        const comment = payload.comment;
+        const publication = parsePackagePublicationMarker(comment?.body);
+        if (!publication)
+            return null;
+        return { deliveryId, event, action, repository: repositoryName, pullRequest: number, publication, pullRequestFacts: null };
+    }
+    const facts = pullRequestFacts(payload, action);
+    if (!facts)
+        return null;
+    return { deliveryId, event, action, repository: repositoryName, pullRequest: number, publication: null, pullRequestFacts: facts };
 }
 export class DeliveryDeduper {
     ttlMs;

package/dist/pool.js

@@ -92,44 +92,8 @@ export class RepositoryWorkerPool {
         this.jobTargets.set(jobId, { repository, prNumber });
         await runScheduledBucket(this.client, repository, this.trustedAuthors, { prNumber, jobId, bucket }, { reconcile: async () => { await this.reconcileTarget(repository, prNumber, jobId, 'schedule.tick'); }, idle: async () => { } }, tickAt, () => this.makeStore(repository, prNumber));
     }
-    async consumeGitHubSignals(signals) {
-        if (this.isRateLimited() || signals.length === 0)
-            return;
-        const repository = signals.find(signal => signal.repository)?.repository;
-        const prNumber = signals.find(signal => signal.prNumber)?.prNumber;
-        if (!repository || !prNumber || !this.repositories.includes(repository))
-            return;
-        if (!this.refreshWebhookSnapshot) {
-            process.stderr.write(`warning: GitHub webhook signal refresh unavailable for ${repository}#${prNumber}\n`);
-            return;
-        }
-        const reasons = [...new Set(signals.map(signal => signal.reason))];
-        const trigger = reasons.join('+') || 'github.webhook';
-        const snapshot = await this.refreshWebhookSnapshot(repository, prNumber, trigger);
-        const sourceEvents = signals.map(signal => signal.event).filter((event) => Boolean(event));
-        for (const item of snapshot.overviews) {
-            this.jobTargets.set(item.job.id, { repository, prNumber });
-            this.seedTargetSnapshot(repository, prNumber, item.job.id, snapshot.seed);
-            if (this.watchedBus) {
-                for (const event of sourceEvents) {
-                    const publication = event.data?.publication;
-                    if (publication && typeof publication === 'object') {
-                        const value = publication;
-                        await this.watchedBus.publish(eventFor(item.job.id, 'release', null, 'package.published', 'succeeded', `Published ${String(value.package ?? 'package')}@${String(value.version ?? 'unknown')}`, 'orchestrator', {
-                            deliveryId: event.data?.deliveryId,
-                            repository,
-                            prNumber,
-                            package: value.package,
-                            version: value.version,
-                            registry: value.registry,
-                            sha: value.sha,
-                        }, event.source));
-                    }
-                    await this.watchedBus.publish(eventFor(item.job.id, 'github', null, 'github.webhook', 'queued', event.message, 'orchestrator', { ...(event.data ?? {}), coordinatorIngress: false, coordinatorRouted: true }, event.source));
-                }
-            }
-            await this.coordinator.accept({ jobId: item.job.id, reason: trigger, repository, prNumber });
-        }
+    async consumeGitHubSignals(_signals) {
+        // GitHub webhooks are fact-only inputs. They must never trigger a GitHub reread.
     }
     async consumeSignals(jobId, signals) {
         for (const signal of signals) {
@@ -258,16 +222,8 @@ export class RepositoryWorkerPool {
                 await this.scheduleSignalCoordinator.acceptTransport({ jobId: event.job_id, reason: this.signalReason(event), event, repository, prNumber });
                 return;
             }
-            if (ingressWebhook && repository && prNumber) {
-                await this.githubSignalCoordinator.acceptTransport({
-                    jobId: `${repository}#${prNumber}`,
-                    reason: this.signalReason(event),
-                    event,
-                    repository,
-                    prNumber,
-                });
+            if (ingressWebhook)
                 return;
-            }
             if (routedWebhook)
                 return;
             const lifecycle = ['task.started', 'task.completed', 'task.failed', 'task.blocked', 'task.unblocked', 'task.cancelled', 'review.started', 'review.approved', 'review.changes_required', 'review.blocked'].includes(event.type);
@@ -301,30 +257,9 @@ export class RepositoryWorkerPool {
         }
         await this.scheduleSignalCoordinator.accept({ jobId: job.id, reason: this.signalReason(event), event, repository: job.repository, prNumber: job.prNumber });
     }
-    async webhookSignal(bus, wake) {
-        if (!wake.repository || !wake.pullRequest)
-            return;
-        const source = { id: `github/${wake.repository}/delivery/${wake.deliveryId}`, component: 'github-webhook' };
-        const event = eventFor('github-webhook', 'github', null, 'github.webhook', 'queued', `GitHub webhook ${wake.event}${wake.action ? ':' + wake.action : ''}`, 'orchestrator', {
-            deliveryId: wake.deliveryId,
-            event: wake.event,
-            action: wake.action,
-            repository: wake.repository,
-            prNumber: wake.pullRequest,
-            publication: wake.publication ?? null,
-            coordinatorIngress: true,
-        }, source);
-        if (bus) {
-            await bus.publish(event);
-            return;
-        }
-        await this.githubSignalCoordinator.accept({
-            jobId: `${wake.repository}#${wake.pullRequest}`,
-            reason: this.signalReason(event),
-            event,
-            repository: wake.repository,
-            prNumber: wake.pullRequest,
-        });
+    async webhookSignal(_bus, _wake) {
+        // Uncorrelated webhook wakeups are intentionally ignored. A caller must first
+        // resolve the target from local cached state and then call webhookWake().
     }
     async webhookWake(bus, job, wake) {
         if (bus) {

package/dist/projected-store.js

@@ -231,6 +231,9 @@ export class ProjectedDurableStore {
         });
     }
     async comments() { return this.github.comments(); }
+    async applyPullRequestFacts(facts) {
+        await this.relay.savePullRequestFacts(structuredClone(facts));
+    }
     async pullRequestState() {
         return (await this.ensurePullRequestFacts()).state;
     }

package/dist/relayd.js

@@ -291,14 +291,18 @@ export async function runDaemon(argv) {
         secret,
         repositories: new Set(repositories),
         wake: async (event) => {
-            if (!event.repository || !event.pullRequest)
+            const targets = cachedOverviews.filter(item => item.job.repository === event.repository && item.job.prNumber === event.pullRequest);
+            if (targets.length === 0)
                 return;
-            try {
-                await pool.webhookSignal(bus, event);
-            }
-            catch (error) {
-                process.stderr.write(`warning: webhook wake unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
+            for (const target of targets) {
+                const store = runtimeStore(event.repository, event.pullRequest);
+                if (event.pullRequestFacts && store.applyPullRequestFacts) {
+                    await store.applyPullRequestFacts({ ...event.pullRequestFacts, observedAt: new Date().toISOString() });
+                    target.githubState = event.pullRequestFacts.state;
+                }
+                await pool.webhookWake(bus, target.job, event);
             }
+            cachedOverviews = dashboardManagedJobs(cachedOverviews);
         }
     } : undefined;
     const exactJob = async (jobId) => {

package/package.json

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