agents-relay 2.0.66 → 2.0.68

package/dist/service-publication.js

@@ -0,0 +1,29 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { eventFor } from './events.js';
+import { SQLiteRelayStore, relayStorePath } from './relay-store.js';
+/** Single-Job service uses the same durable publish facts as the repository daemon. */
+export async function handleServicePublication(job, wake, bus, directory = join(homedir(), '.agents-relay', 'stores')) {
+    if (!wake.publication && !wake.publishFailure)
+        return;
+    const sqlite = new SQLiteRelayStore(relayStorePath(directory, job.repository, job.prNumber));
+    try {
+        await sqlite.recordPublication(job.id, wake.deliveryId, wake.publication, wake.publishFailure ?? null, wake.publicationObservedAt);
+    }
+    finally {
+        sqlite.close();
+    }
+    if (bus) {
+        if (wake.publication) {
+            const event = eventFor(job.id, 'release', null, 'package.published', 'succeeded', 'Published ' + wake.publication.package + '@' + wake.publication.version, 'orchestrator', { ...wake.publication, deliveryId: wake.deliveryId, repository: job.repository, prNumber: job.prNumber });
+            event.event_id = 'github:' + job.id + ':' + wake.deliveryId + ':package.published';
+            await bus.publish(event);
+        }
+        if (wake.publishFailure) {
+            const event = eventFor(job.id, 'release', null, 'package.publish_failed', 'failed', 'Publish failed: ' + wake.publishFailure.stage, 'orchestrator', { ...wake.publishFailure, deliveryId: wake.deliveryId, repository: job.repository, prNumber: job.prNumber });
+            event.event_id = 'github:' + job.id + ':' + wake.deliveryId + ':package.publish_failed';
+            await bus.publish(event);
+        }
+    }
+    // Do not use a publication event to forge a Job state change.
+}

package/dist/store-github.js

@@ -153,12 +153,23 @@ export class GitHubStore {
         const payload = { merge_method: 'squash' };
         if (expectedHeadSha)
             payload.sha = expectedHeadSha;
-        const result = await this.client.request('repos/' + this.repository + '/pulls/' + this.prNumber + '/merge', {
-            method: 'PUT',
-            body: JSON.stringify(payload),
-        });
-        if (result.merged !== true)
-            throw new Error(typeof result.message === 'string' ? result.message : 'Pull request #' + this.prNumber + ' was not merged');
+        try {
+            const result = await this.client.request('repos/' + this.repository + '/pulls/' + this.prNumber + '/merge', {
+                method: 'PUT',
+                body: JSON.stringify(payload),
+            });
+            if (result.merged !== true)
+                throw new Error(typeof result.message === 'string' ? result.message : 'Pull request #' + this.prNumber + ' was not merged');
+        }
+        catch (error) {
+            // Crash recovery can replay a merge after GitHub committed but before
+            // its local acknowledgement. Treat replay as success ONLY after verifying
+            // the actual external PR is already MERGED; never assume success offline.
+            this.prNodeCache = null;
+            const state = await this.pullRequestState().catch(() => null);
+            if (state !== 'MERGED')
+                throw error;
+        }
         this.prNodeCache = null;
     }
     async closePullRequest() {

package/dist/task-update.js

@@ -44,7 +44,7 @@ export async function applyManagedTaskUpdate(store, jobId, taskId, proposed, exp
 }
 export function managedTaskUpdateHandler(locate, wake) {
     return async (jobId, taskId, task, expectedUpdatedAt) => {
-        const target = locate(jobId);
+        const target = await locate(jobId);
         const updated = await applyManagedTaskUpdate(target.store, jobId, taskId, task, expectedUpdatedAt);
         await wake(target.repository, target.prNumber, jobId);
         return updated;

package/dist/workflow/contracts.js

@@ -12,6 +12,9 @@ export const WORKFLOW_EVENT_NAMES = [
     'hold',
     'lease.expired',
     'implementation.completed',
+    'local.completed',
+    'local.merge.requested',
+    'effect.deliverLocalMerge.failed',
     'pr.closed',
     'pr.merged',
     'queue',
@@ -48,7 +51,6 @@ export const WORKFLOW_FACT_NAMES = [
     'scheduledRun',
     'hasUnblock',
     'manualPlan',
-    'prOpen',
     'reviewDisabled',
     'implementationComplete',
     'headAvailable',
@@ -67,6 +69,7 @@ export const WORKFLOW_EFFECT_NAMES = [
     'effect.launchTask',
     'effect.cancelActiveTasks',
     'effect.mergePullRequest',
+    'effect.deliverLocalMerge',
     'effect.cleanupJobWorktree',
 ];
 export const WORKFLOW_EFFECT_POLICIES = {
@@ -88,6 +91,12 @@ export const WORKFLOW_EFFECT_POLICIES = {
         retry: 'workflow',
         observability: 'workflow.effect',
     },
+    'effect.deliverLocalMerge': {
+        idempotency: 'job-local-source-sha',
+        failureEvent: 'effect.deliverLocalMerge.failed',
+        retry: 'workflow',
+        observability: 'workflow.effect',
+    },
     'effect.mergePullRequest': {
         idempotency: 'job-head-sha',
         failureEvent: 'effect.mergePullRequest.failed',

package/dist/workflow/definitions-v2.js

@@ -35,6 +35,8 @@ export const jobLifecycleV2 = load('job-lifecycle', JOB_STATES, {
     implementationComplete: boolGuard('implementationComplete'),
     headAvailable: boolGuard('headAvailable'),
     mergeCapable: boolGuard('mergeCapable'),
+    localCompletionAllowed: boolGuard('localCompletionAllowed'),
+    localMergeReady: boolGuard('localMergeReady'),
 });
 function topologyTargets(graph, from) {
     const source = [...graph.nodes.values()].find(node => node.kind === 'state' && node.semanticId === from);

package/dist/workflow/job-reconcile-v2.js

@@ -1,65 +1,14 @@
 import { decideJobLifecycle, dispatchJobLifecycle } from './lifecycle.js';
-import { implementationComplete } from '../runtime-status.js';
-import { applyHistoricalJobCompatibilityRepair } from './runtime.js';
-function lifecycleInput(facts) {
-    if (facts.prState === 'MERGED')
-        return { event: 'pr.merged', context: {} };
-    if (facts.prState === 'CLOSED')
-        return { event: 'pr.closed', context: { notMerged: true } };
-    return {
-        event: 'reconcile',
-        context: {
-            prOpen: true,
-            headAvailable: Boolean(facts.headSha),
-            mergeCapable: facts.mergeCapable,
-        },
-    };
-}
-function graphFacts(job, facts) {
-    const input = lifecycleInput(facts);
-    if (input.event !== 'reconcile')
-        return input.context;
-    return {
-        ...input.context,
-        reviewDisabled: job.reviewEnabled === false,
-        implementationComplete: implementationComplete(job),
-        autoMerge: job.autoMerge !== false,
-    };
-}
-/**
- * Historical compatibility only. Normal Job lifecycle is always decided by
- * workflow/job-lifecycle.mmd from the PR fact-derived event.
- */
-function repairHistoricalTerminalState(job, facts) {
-    if (['DRAFT', 'ACTIVE', 'COMPLETED', 'CANCELLED'].includes(job.state))
-        return null;
-    if (facts.prState === 'MERGED')
-        applyHistoricalJobCompatibilityRepair(job, 'COMPLETED');
-    else if (facts.prState === 'CLOSED')
-        applyHistoricalJobCompatibilityRepair(job, 'CANCELLED');
-    else
-        return null;
-    return job.state;
-}
+const localFacts = (_job, facts) => ({
+    jobActive: facts.jobActive,
+    implementationComplete: facts.implementationComplete,
+    headAvailable: facts.headAvailable,
+    deliveryReady: facts.deliveryReady,
+});
+/** Local reconciliation cannot invent a completion event; local Git delivery owns it. */
 export function decideJobReconcile(job, facts) {
-    const input = lifecycleInput(facts);
-    return decideJobLifecycle(job, input.event, graphFacts(job, facts));
+    return decideJobLifecycle(job, 'reconcile', localFacts(job, facts));
 }
 export async function dispatchJobReconcile(job, facts, executeEffect, persist) {
-    const repaired = repairHistoricalTerminalState(job, facts);
-    if (repaired) {
-        await persist?.();
-        await executeEffect?.('effect.cancelActiveTasks');
-        return {
-            accepted: true,
-            target: repaired,
-            guard: null,
-            actions: ['effect.cancelActiveTasks'],
-            mutations: [],
-            effects: ['effect.cancelActiveTasks'],
-            reason: 'accepted',
-        };
-    }
-    const input = lifecycleInput(facts);
-    return dispatchJobLifecycle(job, input.event, graphFacts(job, facts), executeEffect, persist);
+    return dispatchJobLifecycle(job, 'reconcile', localFacts(job, facts), executeEffect, persist);
 }

package/dist/workflow/runtime.js

@@ -35,15 +35,30 @@ export function applyTaskMutation(task, mutation) {
     if (mutation === 'mutation.markPlannerUnavailable')
         task.error = 'No objective planner configured';
 }
-export function applyTaskGraphTarget(task, target, timestamp = new Date().toISOString()) { task.state = target; task.updatedAt = timestamp; }
-export function applyJobGraphTarget(job, target, timestamp = new Date().toISOString()) { job.state = target; job.updatedAt = timestamp; }
+export function applyTaskGraphTarget(task, target, timestamp = new Date().toISOString()) {
+    const previous = Date.parse(task.updatedAt), candidate = Date.parse(timestamp);
+    task.state = target;
+    task.updatedAt = Number.isFinite(previous)
+        ? new Date(Math.max(Number.isFinite(candidate) ? candidate : Date.now(), previous + 1)).toISOString()
+        : timestamp;
+}
+export function applyJobGraphTarget(job, target, timestamp = new Date().toISOString()) {
+    const previous = Date.parse(job.updatedAt), candidate = Date.parse(timestamp);
+    job.state = target;
+    job.updatedAt = Number.isFinite(previous)
+        ? new Date(Math.max(Number.isFinite(candidate) ? candidate : Date.now(), previous + 1)).toISOString()
+        : timestamp;
+}
 export function applyTaskWorkflowDecision(task, decision, timestamp = new Date().toISOString()) {
     if (!decision.accepted || !decision.target)
         throw new Error(`Cannot apply rejected workflow decision to task ${task.id}`);
     task.state = decision.target;
     for (const mutation of decision.mutations)
         applyTaskMutation(task, mutation);
-    task.updatedAt = timestamp;
+    const previous = Date.parse(task.updatedAt), candidate = Date.parse(timestamp);
+    task.updatedAt = Number.isFinite(previous)
+        ? new Date(Math.max(Number.isFinite(candidate) ? candidate : Date.now(), previous + 1)).toISOString()
+        : timestamp;
 }
 export function applyJobWorkflowDecision(job, decision, timestamp = new Date().toISOString()) {
     if (!decision.accepted || !decision.target)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.66",
+  "version": "2.0.68",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {
@@ -9,10 +9,12 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && chmod +x dist/cli.js dist/relayd.js dist/relayd-main.js",
-    "test": "npm run build && node --test test/*.test.js",
+    "test": "npm run test:full",
     "test:chatgpt-temp-quality": "AGENTS_RELAY_RUN_CHATGPT_TEMP_QUALITY=1 sh -c \"npm run build && node test/quality/run-temporary-chat.mjs\"",
     "dev": "tsx src/cli.ts",
-    "test:publish": "npm run build && node --test --test-force-exit test/*.test.js"
+    "test:publish": "npm run build && node --test --test-force-exit test/*.test.js",
+    "test:fast": "npm run build && node --test --test-concurrency=2 test/workflow-lifecycle.test.js test/workflow-v2-lifecycle-parity.test.js test/workflow-effects.test.js test/relay-store.test.js test/local-authority.test.js test/local-jobid-routing.test.js test/local-sqlite-jobid.test.js test/no-github.test.js test/scheduled-jobs.test.js test/reconcile-coordinator.test.js test/service-publication.test.js test/github-webhook.test.js",
+    "test:full": "npm run build && node --test --test-concurrency=1 test/*.test.js"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",

package/workflow/job-lifecycle.mmd

@@ -4,73 +4,32 @@ draft["state: DRAFT"]
 active["state: ACTIVE"]
 completed["state: COMPLETED"]
 cancelled["state: CANCELLED"]
-notMergedDraft["guard: notMerged"]
-notMergedActive["guard: notMerged"]
-autoMergeReview["guard: autoMerge"]
-autoMergeImplementation["guard: autoMerge"]
-prOpenReconcile["guard: prOpen"]
-reviewDisabledReconcile["guard: reviewDisabled"]
-implementationCompleteReconcile["guard: implementationComplete"]
-autoMergeReconcile["guard: autoMerge"]
-headAvailableReconcile["guard: headAvailable"]
-mergeCapableReconcile["guard: mergeCapable"]
-mergeReconcile["action: effect.mergePullRequest"]
-cancelDraftMerge["action: effect.cancelActiveTasks"]
-cancelDraftClose["action: effect.cancelActiveTasks"]
-mergeReview["action: effect.mergePullRequest"]
-mergeImplementation["action: effect.mergePullRequest"]
-cancelActiveMerge["action: effect.cancelActiveTasks"]
-cancelActiveClose["action: effect.cancelActiveTasks"]
-cancelCancelledMerge["action: effect.cancelActiveTasks"]
+
+cancelDraft["action: effect.cancelActiveTasks"]
+cancelActive["action: effect.cancelActiveTasks"]
+localCompletionGuard["guard: localCompletionAllowed"]
+localMergeReadyGuard["guard: localMergeReady"]
+localMergeDelivery["action: effect.deliverLocalMerge"]
 
 draft -->|on: activate| active
-draft -->|on: pr.merged| cancelDraftMerge
-cancelDraftMerge --> completed
 draft -->|on: cancel| cancelDraft
-cancelDraft["action: effect.cancelActiveTasks"]
 cancelDraft --> cancelled
-draft -->|on: pr.closed| notMergedDraft
-notMergedDraft -->|true| cancelDraftClose
-cancelDraftClose --> cancelled
-
-active -->|on: reconcile| prOpenReconcile
-prOpenReconcile -->|true| reviewDisabledReconcile
-prOpenReconcile -->|false| active
-reviewDisabledReconcile -->|true| implementationCompleteReconcile
-reviewDisabledReconcile -->|false| active
-implementationCompleteReconcile -->|true| autoMergeReconcile
-implementationCompleteReconcile -->|false| active
-autoMergeReconcile -->|true| headAvailableReconcile
-autoMergeReconcile -->|false| active
-headAvailableReconcile -->|true| mergeCapableReconcile
-headAvailableReconcile -->|false| active
-mergeCapableReconcile -->|true| mergeReconcile
-mergeCapableReconcile -->|false| active
-mergeReconcile --> active
 
-active -->|on: review.approved| autoMergeReview
-autoMergeReview -->|true| mergeReview
-mergeReview --> active
-active -->|on: implementation.completed| autoMergeImplementation
-autoMergeImplementation -->|true| mergeImplementation
-mergeImplementation --> active
-active -->|on: effect.mergePullRequest.failed| active
-active -->|on: pr.merged| cancelActiveMerge
-cancelActiveMerge --> completed
+active -->|on: reconcile| active
+active -->|on: review.approved| active
+active -->|on: implementation.completed| active
 active -->|on: cancel| cancelActive
-cancelActive["action: effect.cancelActiveTasks"]
 cancelActive --> cancelled
-active -->|on: pr.closed| notMergedActive
-notMergedActive -->|true| cancelActiveClose
-cancelActiveClose --> cancelled
 
-cancelled -->|on: pr.merged| cancelCancelledMerge
-cancelCancelledMerge --> completed
-cancelled -->|on: effect.cancelActiveTasks.failed| cancelled
-completed -->|on: effect.cancelActiveTasks.failed| completed
+active -->|on: local.completed| localCompletionGuard
+localCompletionGuard -->|true| completed
+localCompletionGuard -->|false| active
 
-%% Cleanup eligibility belongs to the lifecycle graph and is retryable after restart.
-cleanupCompletedWorktree["action: effect.cleanupJobWorktree"]
-completed -->|on: pr.merged| cleanupCompletedWorktree
-cleanupCompletedWorktree --> completed
+active -->|on: local.merge.requested| localMergeReadyGuard
+localMergeReadyGuard -->|true| localMergeDelivery
+localMergeDelivery --> active
+localMergeReadyGuard -->|false| active
+active -->|on: effect.deliverLocalMerge.failed| active
+
+cancelled -->|on: effect.cancelActiveTasks.failed| cancelled
 completed -->|on: effect.cleanupJobWorktree.failed| completed

package/workflow/review-lifecycle.mmd

@@ -10,7 +10,6 @@ stale["state: STALE"]
 
 unscheduledNone["guard: unscheduled"]
 reviewEnabledNone["guard: reviewEnabled"]
-prOpenNone["guard: prOpen"]
 jobActiveNone["guard: jobActive"]
 implementationCompleteNone["guard: implementationComplete"]
 headAvailableNone["guard: headAvailable"]
@@ -19,7 +18,6 @@ noActiveReviewNone["guard: noActiveReviewTask"]
 noApprovedReviewNone["guard: noApprovedCurrentReview"]
 unscheduledStale["guard: unscheduled"]
 reviewEnabledStale["guard: reviewEnabled"]
-prOpenStale["guard: prOpen"]
 jobActiveStale["guard: jobActive"]
 implementationCompleteStale["guard: implementationComplete"]
 headAvailableStale["guard: headAvailable"]
@@ -47,10 +45,8 @@ mergeStarted["action: review.requestMerge"]
 none -->|on: reconcile| unscheduledNone
 unscheduledNone -->|true| reviewEnabledNone
 unscheduledNone -->|false| none
-reviewEnabledNone -->|true| prOpenNone
+reviewEnabledNone -->|true| jobActiveNone
 reviewEnabledNone -->|false| none
-prOpenNone -->|true| jobActiveNone
-prOpenNone -->|false| none
 jobActiveNone -->|true| implementationCompleteNone
 jobActiveNone -->|false| none
 implementationCompleteNone -->|true| headAvailableNone
@@ -68,10 +64,8 @@ createNone --> pending
 stale -->|on: reconcile| unscheduledStale
 unscheduledStale -->|true| reviewEnabledStale
 unscheduledStale -->|false| stale
-reviewEnabledStale -->|true| prOpenStale
+reviewEnabledStale -->|true| jobActiveStale
 reviewEnabledStale -->|false| stale
-prOpenStale -->|true| jobActiveStale
-prOpenStale -->|false| stale
 jobActiveStale -->|true| implementationCompleteStale
 jobActiveStale -->|false| stale
 implementationCompleteStale -->|true| headAvailableStale