agents-relay 2.0.38 → 2.0.39

package/dist/reconciler.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { storySizeTimeoutMs, chatGptStartAckTimeoutMs } from './types.js';
-import { dependencyReady, schedule, transitionJobEvent, transitionTaskEvent } from './scheduler.js';
+import { dependencyReady, schedule, transitionTaskEvent } from './scheduler.js';
 import { applyTaskCancelAction } from './task-actions.js';
 import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
@@ -13,7 +13,6 @@ import { executeManualPlan } from './manual-plan.js';
 import { executionEventSource, withExecutionBoundary } from './reconciler-runtime.js';
 export { executionEventSource } from './reconciler-runtime.js';
 import { CallbackWorkflowEffectHandler } from './workflow/effects.js';
-import { applyHistoricalJobCompatibilityRepair } from './workflow/runtime.js';
 import { pendingTroubleshooterTasks } from './troubleshooter.js';
 import { prepareManagedExecutionWorktree } from './workspace.js';
 import { createReviewChairExecutionPlan } from './review-chair.js';
@@ -119,23 +118,10 @@ export class Reconciler extends ReconcilerReviewBase {
             await this.invalidateStaleReview(job, headSha);
             const now = (this.options.now ?? new Date()).getTime();
             if (prState !== 'OPEN') {
-                const reason = prState === 'MERGED' ? 'Pull request merged' : 'Pull request closed';
-                const terminalState = prState === 'MERGED' ? 'COMPLETED' : 'CANCELLED';
-                if (job.state !== terminalState) {
-                    if (!['DRAFT', 'ACTIVE', 'COMPLETED', 'CANCELLED'].includes(job.state)) {
-                        // Compatibility repair boundary for historical records that persisted runtime status as lifecycle.
-                        applyHistoricalJobCompatibilityRepair(job, terminalState);
-                        await this.store.saveJob(job);
-                        const outcomes = await this.workflowEffects.execute(['effect.cancelActiveTasks'], { jobId: job.id, transitionKey: `compatibility:${prState}`, data: { reason } });
-                        await this.applyJobEffectOutcomes(job, outcomes);
-                    }
-                    else {
-                        await transitionJobEvent(job, prState === 'MERGED' ? 'pr.merged' : 'pr.closed', prState === 'CLOSED' ? { notMerged: true } : {}, async (actionId) => {
-                            const outcomes = await this.workflowEffects.execute([actionId], { jobId: job.id, transitionKey: `terminal:${prState}`, data: { reason } });
-                            await this.applyJobEffectOutcomes(job, outcomes);
-                        }, async () => { await this.store.saveJob(job); });
-                    }
-                }
+                await dispatchJobReconcile(job, { prState, headSha, mergeCapable: Boolean(this.store.mergePullRequest) }, async (actionId) => {
+                    const outcomes = await this.workflowEffects.execute([actionId], { jobId: job.id, transitionKey: `terminal:${prState}`, data: { reason: `Pull request ${prState.toLowerCase()}` } });
+                    await this.applyJobEffectOutcomes(job, outcomes);
+                }, async () => { await this.store.saveJob(job); });
                 if (prState === 'MERGED' && this.store.resolveBlockerDependents) {
                     const resolved = await this.store.resolveBlockerDependents(job.id, 'merge');
                     for (const target of resolved.unblocked)

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

@@ -1,19 +1,65 @@
 import { decideJobLifecycle, dispatchJobLifecycle } from './lifecycle.js';
 import { implementationComplete } from '../runtime-status.js';
-export function decideJobReconcile(job, facts) {
-    return decideJobLifecycle(job, 'reconcile', {
-        prOpen: facts.prState === 'OPEN',
+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,
-        headAvailable: Boolean(facts.headSha),
-        mergeCapable: facts.mergeCapable,
-    });
+    };
+}
+/**
+ * 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;
+}
+export function decideJobReconcile(job, facts) {
+    const input = lifecycleInput(facts);
+    return decideJobLifecycle(job, input.event, graphFacts(job, facts));
 }
 export async function dispatchJobReconcile(job, facts, executeEffect, persist) {
-    return dispatchJobLifecycle(job, 'reconcile', {
-        prOpen: facts.prState === 'OPEN', reviewDisabled: job.reviewEnabled === false,
-        implementationComplete: implementationComplete(job), autoMerge: job.autoMerge !== false,
-        headAvailable: Boolean(facts.headSha), mergeCapable: facts.mergeCapable,
-    }, 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);
 }

package/package.json

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

package/skills/agents-relay/contracts/orchestrator-workflows.md

@@ -37,3 +37,11 @@ A **P0 job** (alias: **self job**) is executed directly by the current active or
 6. After implementation and local verification, the orchestrator merges the job itself and completes normal post-merge reconciliation.
 
 `job create` still only creates durable job state; the P0 workflow requires the orchestrator to follow it immediately with task creation and execution.
+
+## Merge completion vs deployment evidence
+
+For a normal one-shot managed Job, the canonical Job lifecycle graph owns completion: a durable `pr.merged` fact transitions the Job to `COMPLETED`. Reconciler and deployment code must not invent a second completion gate after merge.
+
+Post-merge publication and deployment activity is separate from Job lifecycle. Events or evidence such as `package.published`, published version metadata, service restart, and deployment verification may be attached after the Job is already `COMPLETED`; they must not hold the Job open, reopen it, or redefine completion. If post-merge deployment needs remediation, record that as separate deployment/recovery work rather than mutating the completed implementation Job lifecycle.
+
+A PR closed without merge follows the same graph-owned rule through `pr.closed -> CANCELLED`.