agents-relay 1.0.164 → 1.0.166

package/dist/reconciler.js

@@ -228,9 +228,17 @@ export class Reconciler extends ReconcilerReviewBase {
         }
     }
     async recoverLostExecutions(job, now) {
-        for (const task of job.tasks.filter(item => item.state === 'RUNNING' || (item.state === 'QUEUED' && item.executionId !== null))) {
-            const expired = task.leaseExpiresAt !== null && new Date(task.leaseExpiresAt).getTime() <= now;
-            if (!expired)
+        const candidates = job.tasks.filter(item => item.state === 'RUNNING' || (item.state === 'QUEUED' && item.executionId !== null));
+        for (const staleTask of candidates) {
+            if (staleTask.leaseExpiresAt === null || new Date(staleTask.leaseExpiresAt).getTime() > now)
+                continue;
+            // Re-read durable state before applying lease recovery: another reconciler may have accepted a terminal event or launched a newer execution.
+            const task = (await this.store.load(job.id)).tasks.find(item => item.id === staleTask.id);
+            if (!task)
+                continue;
+            const sameGeneration = task.executionId === staleTask.executionId && task.leaseOwner === staleTask.leaseOwner && task.leaseExpiresAt === staleTask.leaseExpiresAt;
+            const recoverable = task.state === 'RUNNING' || (task.state === 'QUEUED' && task.executionId !== null);
+            if (!sameGeneration || !recoverable || task.leaseExpiresAt === null || new Date(task.leaseExpiresAt).getTime() > now)
                 continue;
             this.live.get(task.id)?.execution.cancel();
             const planner = this.plannerLive.get(task.id);
@@ -239,8 +247,7 @@ export class Reconciler extends ReconcilerReviewBase {
                 planner.controller.abort();
                 this.plannerLive.delete(task.id);
             }
-            const failedEvent = task.state === 'RUNNING' ? 'task.failed' : 'fail';
-            await transitionTaskEvent(task, failedEvent);
+            await transitionTaskEvent(task, task.state === 'RUNNING' ? 'task.failed' : 'fail');
             task.error = 'Lease expired';
             task.leaseOwner = null;
             task.leaseExpiresAt = null;
@@ -248,12 +255,11 @@ export class Reconciler extends ReconcilerReviewBase {
             if (task.attempt < task.maxAttempts) {
                 await transitionTaskEvent(task, 'retry');
                 await this.store.saveTask(task);
+                continue;
             }
-            else {
-                task.error += ' after maximum attempts';
-                await this.store.saveTask(task);
-                await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.failed', 'failed', task.error, 'user', { reason: 'lease_expired' }));
-            }
+            task.error += ' after maximum attempts';
+            await this.store.saveTask(task);
+            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.failed', 'failed', task.error, 'user', { reason: 'lease_expired' }));
         }
     }
     async planJob(jobId, guidance) {

package/dist/relayd.js

@@ -19,7 +19,9 @@ import { deriveJobRuntimeStatus } from './runtime-status.js';
 import { decisionMode, LayaCliDecisionEngine } from './decision.js';
 import { JsonlDecisionAuditStore } from './decision-audit.js';
 import { summarizeRuntime } from './runtime-summary.js';
+import { dueBuckets, processDueScheduledJobs } from './scheduled-jobs.js';
 const PR_REFRESH_COALESCE_MS = 1000;
+export const SCHEDULE_HEARTBEAT_MS = 600_000;
 export function shouldCoalescePullRequestRefresh(completedAt, now = Date.now(), force = false) {
     return !force && completedAt !== null && now >= completedAt && now - completedAt < PR_REFRESH_COALESCE_MS;
 }
@@ -280,13 +282,29 @@ export async function runDaemon(argv) {
             process.stderr.write(`warning: workspace reconcile unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
         }
     };
+    const scheduleHeartbeatSafely = async () => {
+        if (client.rateLimitStatus().limited)
+            return;
+        const now = new Date();
+        for (const repository of repositories) {
+            try {
+                await processDueScheduledJobs({ client, repository, trustedAuthors: trusted, buckets: dueBuckets(now, 36), now, engine: job => ({ reconcile: async () => { await pool.reconcileTarget(repository, job.prNumber, job.id); }, idle: async () => { } }) });
+            }
+            catch (error) {
+                process.stderr.write(`warning: scheduled heartbeat unavailable for ${repository}: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
+    };
     const watchdogDefault = webhook ? SERVICE_DEFAULTS.webhookWatchdogMs : SERVICE_DEFAULTS.watchdogMs;
     const interval = setInterval(() => void reconcileSafely(), Number(value(argv, '--interval', String(watchdogDefault))));
     interval.unref();
-    const stop = () => { clearInterval(interval); void stopWatch().finally(() => server.close(() => process.exit(0))); };
+    const scheduleInterval = setInterval(() => void scheduleHeartbeatSafely(), SCHEDULE_HEARTBEAT_MS);
+    scheduleInterval.unref();
+    const stop = () => { clearInterval(interval); clearInterval(scheduleInterval); void stopWatch().finally(() => server.close(() => process.exit(0))); };
     process.once('SIGINT', stop);
     process.once('SIGTERM', stop);
     console.log('Dashboard listening; repository worker pool active');
+    void scheduleHeartbeatSafely();
     void refreshAll(true)
         .then(items => pool.reconcileKnown(items))
         .catch(error => process.stderr.write(`warning: startup reconciliation unavailable: ${error instanceof Error ? error.message : String(error)}\n`));

package/package.json

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

package/skills/agents-relay/contracts/task-job-contract.md

@@ -109,7 +109,9 @@ SHA-bound final reviewer. For example, `video-director + market + style ->
 review-chair -> unified revision plan` is a project pattern, not a hard-coded
 Relay reviewer list.
 
-A scheduled autonomous job adds cron/timezone/next-run and missed-run/concurrency policy to the trusted job marker, plus the `agents-relay:autonomous` label and one bounded time-of-day `agents-relay:next-run:*` index label. The GitHub heartbeat discovers only indexed due candidates, validates the marker's exact `nextRunAt`, claims the slot idempotently, advances the durable next run, and pulses `agents-relay:schedule-wake`. GitHub webhook delivery then wakes local Relay for planner/worker execution. While the schedule is active, the durable Job remains `ACTIVE`; between runs its derived runtime status is `WAITING`. Scheduled recurring Jobs do not enter one-shot final-review/auto-merge after each satisfied run; older-cycle failures are historical evidence and do not block a later slot.
+A scheduled autonomous job adds cron/timezone/next-run and missed-run/concurrency policy to the trusted job marker, plus the `agents-relay:autonomous` label and one bounded time-of-day `agents-relay:next-run:*` index label. The always-on `agents-relayd` process is the authoritative heartbeat for repositories it manages: it evaluates due schedule buckets on startup and every ten minutes and reconciles claimed work through the local worker pool. A repository may also install `.github/workflows/autonomous-scheduler.yml` as an optional cloud fallback; GitHub `schedule` delivery is best-effort and must not be relied on for precise cadence. Unscheduled autonomous Jobs and fixed Jobs do not use the scheduler heartbeat.
+
+The scheduler heartbeat discovers only indexed due candidates, validates the marker's exact `nextRunAt`, claims the slot idempotently, advances the durable next run, and pulses `agents-relay:schedule-wake`. GitHub webhook delivery then wakes local Relay for planner/worker execution. While the schedule is active, the durable Job remains `ACTIVE`; between runs its derived runtime status is `WAITING`. Scheduled recurring Jobs do not enter one-shot final-review/auto-merge after each satisfied run; older-cycle failures are historical evidence and do not block a later slot.
 
 
 ## Task evidence and head identity