agents-relay 1.0.171 → 1.0.173

package/dist/pool.js

@@ -176,7 +176,18 @@ export class RepositoryWorkerPool {
             capacity -= allowance;
         }
     }
-    async reconcileKnown(discovered) { await this.reconcileDiscovered(discovered); }
+    async reconcileKnown(discovered) {
+        for (const item of discovered.filter(value => value.githubState === 'OPEN' && value.job.state === 'ACTIVE')) {
+            this.jobTargets.set(item.job.id, { repository: item.job.repository, prNumber: item.job.prNumber });
+            const store = new GitHubStore(this.client, item.job.repository, item.job.prNumber, this.trustedAuthors);
+            const reconciler = this.makeReconciler(store, 0);
+            if (typeof reconciler.recoverStartupOrphans === 'function')
+                await this.reconcileExclusive(item.job.id, async () => {
+                    await withGitHubRequestContext(this.client, 'pool.startup-orphan-recovery', () => reconciler.recoverStartupOrphans(item.job.id));
+                });
+        }
+        await this.reconcileDiscovered(discovered);
+    }
     async reconcile() {
         if (this.isRateLimited())
             return;

package/dist/reconciler-review.js

@@ -104,7 +104,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const registered = await this.store.listAgents();
         const candidates = workerCandidates(this.options.adapters, registered, usage);
         const runtimeSummary = this.options.runtimeSummaryProvider?.();
-        for (const task of job.tasks.filter(item => item.kind !== 'planner' && item.agentName !== 'reviewer' && item.adapter !== 'orchestrator' && ['QUEUED', 'BLOCKED'].includes(item.state) && item.output && !item.workerSelection && (item.workerRequirements || item.planningSource === 'model-planner'))) {
+        for (const task of job.tasks.filter(item => item.kind !== 'planner' && item.adapter !== 'orchestrator' && ['QUEUED', 'BLOCKED'].includes(item.state) && item.output && !item.workerSelection && (item.workerRequirements || item.planningSource === 'model-planner'))) {
             const requirements = task.workerRequirements ?? { capabilities: [] };
             const taskFacts = {
                 id: task.id,

package/dist/reconciler.js

@@ -214,6 +214,8 @@ export class Reconciler extends ReconcilerReviewBase {
             this.reconciling = false;
         }
     }
+    async recoverStartupOrphans(jobId) { const job = await this.store.load(jobId); if (job.state === 'ACTIVE' && (await this.store.pullRequestState?.() ?? 'OPEN') === 'OPEN')
+        await this.recoverOrphanedLocalExecutions(job); return this.store.load(jobId); }
     async cancelActiveTasks(jobId, reason) {
         const job = await this.store.load(jobId);
         for (const task of job.tasks.filter(item => !['SUCCEEDED', 'FAILED', 'CANCELLED'].includes(item.state))) {
@@ -262,6 +264,26 @@ export class Reconciler extends ReconcilerReviewBase {
             await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.failed', 'failed', task.error, 'user', { reason: 'lease_expired' }));
         }
     }
+    async recoverOrphanedLocalExecutions(job) {
+        for (const stale of job.tasks.filter(t => t.state === 'RUNNING' && t.executionId && t.leaseOwner && t.leaseOwner !== this.options.owner && t.adapter !== 'chatgpt')) {
+            const task = (await this.store.load(job.id)).tasks.find(t => t.id === stale.id);
+            if (!task || task.state !== 'RUNNING' || task.executionId !== stale.executionId || task.leaseOwner !== stale.leaseOwner || task.leaseExpiresAt !== stale.leaseExpiresAt || task.adapter === 'chatgpt' || task.leaseOwner === this.options.owner)
+                continue;
+            await transitionTaskEvent(task, 'task.failed');
+            task.error = 'Orphaned after relayd restart';
+            task.leaseOwner = null;
+            task.leaseExpiresAt = null;
+            task.executionId = null;
+            if (task.attempt < task.maxAttempts) {
+                await transitionTaskEvent(task, 'retry');
+                await this.store.saveTask(task);
+                continue;
+            }
+            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: 'startup_orphaned' }));
+        }
+    }
     async planJob(jobId, guidance) {
         return executeManualPlan(this.store, jobId, guidance, this.options.plannerTimeoutMs ?? storySizeTimeoutMs('M'), (job, task) => this.launchPlanner(job, task));
     }

package/dist/relayd.js

@@ -120,7 +120,7 @@ export async function runDaemon(argv) {
             cachedOverviews = parsed;
     }
     catch { /* first run or invalid cache */ }
-    const refreshAll = async (full = false) => {
+    const refreshAll = async (full = false, failOnError = false) => {
         if (client.rateLimitStatus().limited)
             return cachedOverviews;
         const scanRepositories = full ? repositories : recoveryScanRepositories(repositories, cachedOverviews, dormantProbeIndex++);
@@ -139,6 +139,8 @@ export async function runDaemon(argv) {
             return cachedOverviews;
         }
         catch (error) {
+            if (failOnError)
+                throw error;
             process.stderr.write(`warning: workspace job refresh unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
             return cachedOverviews;
         }
@@ -275,7 +277,6 @@ export async function runDaemon(argv) {
         taskCancel: workspaceTaskAction('cancel'),
         taskSetState: workspaceTaskSetState,
     });
-    await once(server, 'listening');
     const reconcileSafely = async () => {
         if (client.rateLimitStatus().limited)
             return;
@@ -301,17 +302,23 @@ export async function runDaemon(argv) {
         }
     };
     const watchdogDefault = webhook ? SERVICE_DEFAULTS.webhookWatchdogMs : SERVICE_DEFAULTS.watchdogMs;
-    const interval = setInterval(() => void reconcileSafely(), Number(value(argv, '--interval', String(watchdogDefault))));
-    interval.unref();
-    const scheduleInterval = setInterval(() => void scheduleHeartbeatSafely(), SCHEDULE_HEARTBEAT_MS);
-    scheduleInterval.unref();
-    const stop = () => { clearInterval(interval); clearInterval(scheduleInterval); void stopWatch().finally(() => server.close(() => process.exit(0))); };
+    let interval;
+    let scheduleInterval;
+    const stop = () => { if (interval)
+        clearInterval(interval); if (scheduleInterval)
+        clearInterval(scheduleInterval); void stopWatch().finally(() => server.close(() => process.exit(0))); };
     process.once('SIGINT', stop);
     process.once('SIGTERM', stop);
+    await once(server, 'listening');
+    const startupItems = await refreshAll(true, true); // void refreshAll(true)
+    await pool.reconcileKnown(startupItems);
+    // Startup recovery must finish before normal polling or scheduled work can run.
+    await scheduleHeartbeatSafely();
+    interval = setInterval(() => void reconcileSafely(), Number(value(argv, '--interval', String(watchdogDefault))));
+    interval.unref();
+    scheduleInterval = setInterval(() => void scheduleHeartbeatSafely(), SCHEDULE_HEARTBEAT_MS);
+    scheduleInterval.unref();
     console.log('Dashboard listening; repository worker pool active');
-    void refreshAll(true)
-        .then(async (items) => { await scheduleHeartbeatSafely(); await pool.reconcileKnown(items); })
-        .catch(error => process.stderr.write(`warning: startup reconciliation unavailable: ${error instanceof Error ? error.message : String(error)}\n`));
 }
 if (isEntrypoint(import.meta.url))
     runDaemon(process.argv.slice(2)).catch(error => { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1; });

package/package.json

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