agents-relay 1.0.102 → 1.0.104

package/dist/workflow/durable-transition.js

@@ -0,0 +1,45 @@
+import { tryTransitionTaskEvent } from '../scheduler.js';
+/**
+ * Runtime primitive for applying one canonical Task-graph event to fresh durable state.
+ *
+ * This class owns serialization and persistence only. It does not decide lifecycle
+ * legality: the canonical Mermaid Task graph does that through tryTransitionTaskEvent.
+ */
+export class DurableTaskTransitionRuntime {
+    store;
+    locks = new Map();
+    constructor(store) {
+        this.store = store;
+    }
+    async apply(jobId, taskId, event, options = {}) {
+        return this.withLock(`${jobId}/${taskId}`, async () => {
+            const job = await this.store.load(jobId);
+            const task = job.tasks.find(item => item.id === taskId);
+            if (!task || (options.eligible && !options.eligible(job, task)))
+                return null;
+            const from = task.state;
+            const decision = tryTransitionTaskEvent(task, event, options.facts?.(job, task) ?? {});
+            if (!decision.accepted || !decision.target)
+                return { job, task, from, decision };
+            await options.mutate?.(job, task, decision);
+            await this.store.saveTask(task);
+            return { job, task, from, decision };
+        });
+    }
+    async withLock(key, work) {
+        const previous = this.locks.get(key);
+        let release;
+        const current = new Promise(resolve => { release = resolve; });
+        this.locks.set(key, current);
+        if (previous)
+            await previous;
+        try {
+            return await work();
+        }
+        finally {
+            release();
+            if (this.locks.get(key) === current)
+                this.locks.delete(key);
+        }
+    }
+}

package/dist/workflow/runtime.js

@@ -37,3 +37,10 @@ export function applyJobWorkflowDecision(job, decision, timestamp = new Date().t
     job.state = decision.target;
     job.updatedAt = timestamp;
 }
+/** Historical repair for records that stored derived runtime status as Job lifecycle. */
+export function applyHistoricalJobCompatibilityRepair(job, target, timestamp = new Date().toISOString()) {
+    if (target !== 'COMPLETED' && target !== 'CANCELLED')
+        throw new Error(`Invalid historical Job repair target ${target}`);
+    job.state = target;
+    job.updatedAt = timestamp;
+}

package/package.json

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

package/skills/agents-relay/agents/implementation.agent.md

@@ -0,0 +1,24 @@
+---
+name: implementation
+description: Implement the assigned Agents Relay task in the managed checkout and verify the durable result.
+capabilities: [implementation, local_repo, iterative_tools]
+runtime: codex
+delegation: [relay-child-task]
+restrictions: [preserve-user-changes, no-unrelated-refactors]
+---
+
+# Implementation Agent
+
+Implement the assigned Task in the current managed checkout. Treat the durable
+Job objective and Task input retrieved from GitHub as authoritative. Inspect the
+existing design before editing, keep the change narrowly scoped, and preserve
+unrelated user work.
+
+Follow the shared Agents Relay and events-bus contracts. Publish the required
+canonical `task.started` event before doing work, then exactly one terminal task
+event after the declared output is durable. Use the exact execution source
+identity supplied by Relay for every lifecycle event.
+
+Run the most relevant tests and checks for the change. Do not claim completion
+without durable implementation evidence, validation results, and a concise
+summary of changed files and remaining risks.

package/skills/agents-relay/agents/planner.agent.md

@@ -58,6 +58,8 @@ Do not create separate Tasks merely for "analyze", "format", "call tool", "check
 ## Rules
 
 - Treat durable Job/Task state as authoritative.
+- Discover visible agents from the resolved execution context before selecting an agent. Choose an existing visible agent only when it is appropriate for the Task; otherwise leave `agentName` unset. Agent discovery is runtime/context-specific, not a hardcoded global list.
+- Build `agentGraph` nodes only from agents in the discovered visible-agent catalog. Every named graph agent must be visible in the resolved planning/execution context.
 - Never invent completed work or evidence.
 - First decide whether the objective is already satisfied.
 - If satisfied, return `objective_status: "satisfied"` and `next_tasks: []`.

package/workflow/task-lifecycle.mmd

@@ -14,20 +14,26 @@ stateDiagram-v2
     QUEUED --> BLOCKED: block
     QUEUED --> FAILED: fail
     QUEUED --> FAILED: effect.launchTask.failed
+    QUEUED --> FAILED: watchdog.failed
+    QUEUED --> FAILED: worker.delivery_failed
+    QUEUED --> FAILED: worker.start_ack_failed
     QUEUED --> CANCELLED: cancel
 
     RUNNING --> BLOCKED: task.blocked
     RUNNING --> SUCCEEDED: task.completed / mutation.clearError,mutation.clearFailureReason
     RUNNING --> FAILED: task.failed
+    RUNNING --> FAILED: watchdog.failed
     RUNNING --> CANCELLED: task.cancelled
 
     BLOCKED --> QUEUED: retry / mutation.clearError,mutation.clearFailureReason
     BLOCKED --> CANCELLED: cancel
 
     FAILED --> QUEUED: retry / mutation.clearError,mutation.clearFailureReason
-    FAILED --> RUNNING: reconcile.started / mutation.clearError,mutation.clearFailureReason
-    FAILED --> SUCCEEDED: reconcile.completed / mutation.clearError,mutation.clearFailureReason
-    FAILED --> BLOCKED: reconcile.blocked
+    FAILED --> RUNNING: task.started [recoverableExecution] / mutation.clearError,mutation.clearFailureReason
+    FAILED --> SUCCEEDED: task.completed [recoverableExecution] / mutation.clearError,mutation.clearFailureReason
+    FAILED --> BLOCKED: task.blocked [recoverableExecution]
+    FAILED --> FAILED: task.failed [recoverableExecution]
+    FAILED --> CANCELLED: task.cancelled [recoverableExecution]
     FAILED --> CANCELLED: cancel
 
     SUCCEEDED --> [*]