agents-relay 1.0.96 → 1.0.98

package/dist/reconciler-runtime.js

@@ -165,13 +165,14 @@ export class ReconcilerRuntimeBase {
         this.detach(this.reconcile(job.id), job.id, task.id, 'late worker-start reconciliation');
     }
     isRecoverableWatchdogFailure(task) {
-        if (['worker_start_timeout', 'terminal_event_timeout', 'worker_exit_before_start', 'worker_exit_without_terminal_event'].includes(task.failureReason ?? ''))
+        if (['worker_start_timeout', 'terminal_event_timeout', 'worker_exit_before_start', 'worker_exit_without_terminal_event', 'worker_delivery_after_start'].includes(task.failureReason ?? ''))
             return true;
         const error = task.error ?? '';
         return error.includes('worker_start_timeout')
             || error.includes('timed out waiting for the mandatory terminal worker event')
             || error.includes('exited before publishing task.started')
-            || error.includes('exited after task.started without publishing a terminal task event');
+            || error.includes('exited after task.started without publishing a terminal task event')
+            || error.includes('Worker delivery failed after task.started');
     }
     isCorrelatedWorkerEvent(task, event) {
         return task.executionId !== null && eventSourceId(event) === executionEventSource(event.job_id, task.id, task.executionId);
@@ -187,19 +188,18 @@ export class ReconcilerRuntimeBase {
         const task = job.tasks.find(item => item.id === taskId);
         if (!task || task.executionId !== executionId || !['QUEUED', 'RUNNING'].includes(task.state))
             return;
-        const event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', `Worker ${phase} failed: ${message}`, 'user', { phase, reason: phase === 'start-ack' ? 'worker_start_timeout' : undefined }, { agent: 'relay', component: 'agents-relay', watchdog: true });
-        if (task.state === 'QUEUED') {
-            this.clearExecution(task.id, executionId);
-            task.error = event.message;
-            task.failureReason = phase === 'start-ack' ? 'worker_start_timeout' : undefined;
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            await transitionTaskEvent(task, 'fail');
-            await this.store.saveTask(task);
-        }
-        else {
-            await this.applyTerminalEvent(event, true);
+        if (task.state === 'RUNNING') {
+            await this.emit(eventFor(jobId, taskId, task.parentTaskId, 'task.process.delivery_failed', 'failed', `Worker ${phase} reported after task.started: ${message}`, 'orchestrator', { phase, authoritative: false, executionId }, { agent: 'relay', component: 'agents-relay' }));
+            return;
         }
+        const event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', `Worker ${phase} failed: ${message}`, 'user', { phase, reason: phase === 'start-ack' ? 'worker_start_timeout' : undefined }, { agent: 'relay', component: 'agents-relay', watchdog: true });
+        this.clearExecution(task.id, executionId);
+        task.error = event.message;
+        task.failureReason = phase === 'start-ack' ? 'worker_start_timeout' : undefined;
+        task.leaseOwner = null;
+        task.leaseExpiresAt = null;
+        await transitionTaskEvent(task, 'fail');
+        await this.store.saveTask(task);
         await this.emit(event);
     }
     async runtimeSettled(jobId, taskId, executionId, result, error) {

package/dist/reconciler.js

@@ -203,7 +203,7 @@ export class Reconciler extends ReconcilerReviewBase {
         for (const task of job.tasks.filter(item => !['SUCCEEDED', 'FAILED', 'CANCELLED'].includes(item.state))) {
             this.live.get(task.id)?.execution.cancel();
             this.plannerLive.get(task.id)?.controller.abort();
-            await transitionTaskEvent(task, 'cancel');
+            await transitionTaskEvent(task, task.state === 'RUNNING' ? 'task.cancelled' : 'cancel');
             task.error = reason;
             task.leaseOwner = null;
             task.leaseExpiresAt = null;

package/dist/troubleshooter.js

@@ -30,6 +30,18 @@ function belongsToCurrentRun(job, task) {
     const slot = job.schedule?.currentRunSlot;
     return !slot || task.createdAt >= slot;
 }
+const ACTIVE_RECOVERY_STATES = new Set(['DRAFT', 'QUEUED', 'RUNNING', 'BLOCKED']);
+function recoveryTargetsTask(recovery, original) {
+    if (recovery.agentName !== 'troubleshooter')
+        return false;
+    if (recovery.parentTaskId)
+        return recovery.parentTaskId === original.id;
+    return recovery.id.startsWith(`troubleshoot-${slug(original.id)}-a`);
+}
+function hasRecoveryBarrier(job, original) {
+    return job.tasks.some(task => recoveryTargetsTask(task, original)
+        && (ACTIVE_RECOVERY_STATES.has(task.state) || ['FAILED', 'CANCELLED'].includes(task.state)));
+}
 export function pendingTroubleshooterTasks(job) {
     const existing = new Set(job.tasks.filter(task => task.agentName === 'troubleshooter').map(task => task.id));
     const recoveries = [];
@@ -37,7 +49,7 @@ export function pendingTroubleshooterTasks(job) {
         if (!['FAILED', 'BLOCKED'].includes(task.state) || task.kind === 'planner' || task.agentName === 'troubleshooter' || !belongsToCurrentRun(job, task))
             continue;
         const id = troubleshooterTaskId(task);
-        if (existing.has(id))
+        if (existing.has(id) || hasRecoveryBarrier(job, task))
             continue;
         const now = new Date().toISOString();
         recoveries.push({
@@ -48,7 +60,7 @@ export function pendingTroubleshooterTasks(job) {
             storySize: 'M',
             projectName: job.title,
             agentName: 'troubleshooter',
-            parentTaskId: null,
+            parentTaskId: task.id,
             dependencies: [],
             capabilities: ['troubleshoot', 'recovery'],
             workerRequirements: { capabilities: ['model', 'local_repo', 'iterative_tools'], runtime: 'codex' },

package/package.json

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

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

@@ -8,15 +8,62 @@ You are a pure planning agent. Relay invokes you with the durable Job, existing
 
 Relay persists each successful planner invocation as one planner round and creates the returned Tasks under that round.
 
+## Planning contract
+
+**Plan the whole objective before choosing Task boundaries.**
+
+For every non-satisfied objective:
+
+1. Reconstruct the end-to-end execution flow from the current durable state to objective completion.
+2. Express that flow as a compact Mermaid graph in `assessment`.
+3. Mark the points in that graph that deserve durable Task boundaries.
+4. Create only the next useful executable Task batch from those boundaries.
+
+A Task is **not** just a workflow step. Create a Task when its outcome deserves an independent durable lifecycle because it may need to be:
+
+- discussed or referenced later;
+- independently reviewed, approved, revised, or compared;
+- blocked/retried/reconciled independently;
+- waited on as a meaningful external dependency;
+- executed in parallel with a separately meaningful outcome; or
+- preserved as an independently useful deliverable or decision.
+
+If an intermediate result does not need that independent lifecycle, keep it inside the executing Task's agent graph/workflow rather than promoting it to another Task.
+
+Keep sibling Tasks at a comparable abstraction level. Do not mix a whole product milestone with tiny implementation steps as peers.
+
+The graph is the explanation for the decomposition: every emitted Task should map to a meaningful boundary in the graph, and important graph boundaries should not be omitted accidentally.
+
+### Examples
+
+Prefer:
+
+```text
+Task: Create and publish today's vlog
+  internal graph: collect media -> select story -> script -> edit -> captions -> QA -> publish
+```
+
+when nobody needs to separately review or discuss those intermediate outputs.
+
+But when script approval is a real durable gate, prefer:
+
+```text
+Task 1: Produce script for review
+  -> approval/revision boundary
+Task 2: Produce and publish the approved vlog
+```
+
+Do not create separate Tasks merely for "analyze", "format", "call tool", "check status", or other internal mechanics.
+
 ## Rules
 
 - Treat durable Job/Task state as authoritative.
 - Never invent completed work or evidence.
 - First decide whether the objective is already satisfied.
 - If satisfied, return `objective_status: "satisfied"` and `next_tasks: []`.
-- Otherwise return only the next useful executable batch.
+- Otherwise return only the next useful executable batch from the graph-derived Task boundaries.
 - Do not repeat completed work or recreate an existing Task unless replacement work is explicitly needed.
-- Prefer small independently verifiable Tasks with stable IDs.
+- Prefer independently verifiable Tasks with stable IDs, but do not split work solely to make Tasks smaller.
 - A Task describes what an agent must accomplish; never emit a shell command as a worker Task.
 - Use dependencies only when execution order actually matters.
 - Every child Task must declare `workerRequirements`; worker-router selects the worker and model-router selects provider/model/reasoning afterward.
@@ -30,4 +77,11 @@ Relay persists each successful planner invocation as one planner round and creat
 
 Return exactly one JSON object with `objective_status`, `assessment`, and `next_tasks`.
 
+For `objective_status: "in_progress"`, `assessment` must be Markdown containing:
+
+1. a compact Mermaid graph of the full remaining objective flow;
+2. a short explanation of the chosen durable Task boundaries.
+
+For `objective_status: "satisfied"`, `assessment` may be a concise evidence-based completion assessment without a graph.
+
 Each item in `next_tasks` contains `id`, `input`, `workerRequirements`, `output`, and `storySize`. It may also contain priority, projectName, agentName, dependencies, capabilities, maxAttempts, and timeoutMs. Adapter/routing fields are selected by Relay after planning; do not invent them.