agents-relay 2.0.113 → 2.0.115

package/dist/reconciler-runtime.js

@@ -100,7 +100,7 @@ export class ReconcilerRuntimeBase {
             const task = (await this.store.load(event.job_id)).tasks.find(item => item.id === event.task_id);
             const normalized = task?.agentName === 'reviewer' ? normalizeReviewerTerminalEvent(event) : null;
             if (normalized)
-                return this.applyReviewEvent(normalized);
+                return normalized.type === 'task.failed' ? this.applyTerminalEvent(normalized) : this.applyReviewEvent(normalized);
         }
         if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type)) {
             const result = await this.applyTerminalEvent(event);
@@ -110,7 +110,9 @@ export class ReconcilerRuntimeBase {
             return durable?.state === 'FAILED' && durable.executionHistory?.some(history => history.id === event.data?.executionId)
                 ? { applied: true, reconcile: true, reason: 'watchdog.failure-fact' } : result;
         }
-        if (['review.started', 'review.approved', 'review.changes_required', 'review.blocked'].includes(event.type))
+        if (event.type === 'review.blocked')
+            return this.applyTerminalEvent({ ...event, type: 'task.failed', data: { ...event.data, reason: 'review_evidence_unavailable' } });
+        if (['review.started', 'review.approved', 'review.changes_required'].includes(event.type))
             return this.applyReviewEvent(event);
         if (event.type === 'task.interactive_decision')
             return this.applyHostInvocationEvent(event);
@@ -399,6 +401,8 @@ export class ReconcilerRuntimeBase {
             eligible: (_job, task) => {
                 if (!['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
                     return false;
+                if (event.type === 'task.blocked' && (!trustedInternal || task.agentName !== 'troubleshooter') && task.interactiveInvocation?.status !== 'awaiting_decision')
+                    return false;
                 if (task.agentName === 'reviewer' && event.type === 'task.completed')
                     return false;
                 if (event.type === 'task.completed' && task.interactiveInvocation?.status !== undefined && task.interactiveInvocation.status !== 'approved')
@@ -474,7 +478,7 @@ export class ReconcilerRuntimeBase {
         if (event.type === 'task.completed')
             await this.deliverContinuation(transition.job, transition.task);
         const reviewWorker = transition.task.agentName === 'reviewer';
-        return { applied: true, reconcile: !reviewWorker, reason: reviewWorker ? `${event.type}.review-worker` : event.type, reconcileMode: reviewWorker ? undefined : 'detached' };
+        return { applied: true, reconcile: !reviewWorker || event.type === 'task.failed', reason: reviewWorker ? `${event.type}.review-worker` : event.type, reconcileMode: reviewWorker ? undefined : 'detached' };
     }
     terminalWait(taskId, executionId, launchBarrier) {
         let resolve;

package/dist/review-terminal-normalization.js

@@ -9,7 +9,7 @@ export function normalizeReviewerTerminalEvent(event) {
     const raw = data.verdict;
     const type = raw === 'approved' || raw === 'pass' ? 'review.approved'
         : raw === 'changes-required' || raw === 'changes_required' ? 'review.changes_required'
-            : raw === 'blocked' ? 'review.blocked' : null;
+            : raw === 'blocked' ? 'task.failed' : null;
     if (!type)
         return null;
     const outcome = record(data.outcome);
@@ -24,6 +24,8 @@ export function normalizeReviewerTerminalEvent(event) {
         return null;
     const existingFindings = outcome.blocking_findings ?? outcome.blockingFindings;
     const findings = existingFindings ?? (Array.isArray(data.findings) ? data.findings : undefined);
+    if (type === 'task.failed')
+        return { ...event, type, message: event.message || 'Reviewer validation unavailable', data: { ...data, reason: 'review_evidence_unavailable' } };
     return { ...event, type, data: { ...data, outcome: {
                 ...outcome, ...(head ? { head_sha: head } : {}),
                 ...(findings !== undefined && existingFindings === undefined ? { blocking_findings: findings } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.113",
+  "version": "2.0.115",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "repository": {
     "type": "git",

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

@@ -11,19 +11,19 @@ Review exactly the immutable target/version specified by the Review Task. Do not
 
 ## Review Scope
 
-Reconstruct all material acceptance requirements from the durable Job objective and Task, then evaluate each with direct evidence. Check correctness, completeness, provenance, quality, regressions, explicit approvals and externally observable outcomes where applicable. Missing evidence is BLOCKED, not PASS. Keep review independent of implementation work.
+Reconstruct all material acceptance requirements from the durable Job objective and Task, then evaluate each with direct evidence. Check correctness, completeness, provenance, quality, regressions, explicit approvals and externally observable outcomes where applicable. Missing evidence is not PASS. If validation cannot complete, report task.failed. Keep review independent of implementation work.
 
 ## Review Decision
 
-Return a concrete approved, changes-required or blocked verdict tied to the declared immutable target, with attributed findings, severity and remediation steps. Do not alter artifacts, generate approvals on behalf of users, or perform publication, merges or external actions. Relay owns the review lifecycle and Task/Job completion.
+Return a concrete approved or changes-required verdict tied to the declared immutable target, with attributed findings, severity and remediation steps. Do not alter artifacts, generate approvals on behalf of users, or perform publication, merges or external actions. Relay owns the review lifecycle and Task/Job completion.
 
 ## Unified execution event
 
 After completing the review, publish **`task.completed`**, including `data.verdict`
-(`approved`, `changes-required`, or `blocked`), the **exact immutable**
+(`approved` or `changes-required`), the **exact immutable**
 `data.head_sha`, and actionable `data.findings` for changes required. A
 negative verdict is a successful review, not `task.failed`. If review
-execution fails and no sound verdict can be produced, publish `task.failed`.
+execution fails or required validation evidence is unavailable, publish `task.failed`.
 Never emit `review.*` as the agent's terminal event. The event source must
 match the execution identity supplied by Relay. See
 `../contracts/event-contract.md`.

package/skills/agents-relay/contracts/event-contract.md

@@ -16,7 +16,7 @@ Every Implementation, Reviewer, and Troubleshooter execution publishes `task.sta
 | Role | `task.completed.data` | Relay action |
 | --- | --- | --- |
 | Implementation | Evidence of output/artifact, validation, and summary as required by the Task | Persist Task success and continue dependencies/review |
-| Reviewer | `verdict` (`approved`, `changes-required`, or `blocked`), exact immutable `head_sha`, actionable `findings` as necessary | Validate current immutable review target and apply verdict; defects are a successful Reviewer execution, not `task.failed` |
+| Reviewer | `verdict` (`approved` or `changes-required`), exact immutable `head_sha`, actionable `findings` as necessary | Validate current immutable review target and apply verdict; defects are a successful Reviewer execution, not `task.failed` |
 | Troubleshooter | Recovery action and durable evidence of verified original Task retry, blocker-Job handoff, or other authorized recovery | Complete recovery Task only; original Task state changes through separately authorized Relay operations |
 
 A Reviewer must **not** publish unstructured `task.completed`: missing verdict or immutable head is invalid. Relay normalizes an authenticated structured Reviewer terminal event into its internal Review decision; native `review.*` events may be accepted for backward compatibility.
@@ -28,3 +28,7 @@ Only a real user action merits escalation. Troubleshooter invokes the Relay esca
 When the human responds, the **Troubleshooter Task** is authoritatively unblocked and resumed with its prior context plus the response. Troubleshooter independently verifies resolution, requests an authorized original Task recovery, and only then publishes its own `task.completed`. If unresolved, it continues diagnosis or escalates again; human assertion alone is not technical verification.
 
 See [task-recovery-flows.md](task-recovery-flows.md) for unified architecture, overall flow, failure recovery, and post-blocked resumption.
+
+Reviewer unavailable evidence is an execution failure (`task.failed`), not a blocked Task. Legacy Reviewer verdict `blocked` is normalized to failure and must dispatch Troubleshooter. Only Relay blocks a Troubleshooter during human escalation.
+
+A host-mediated interactive invocation is a separate Relay-controlled wait. It requires an already-bound `interactiveInvocation` with status `awaiting_decision`. It is not permission for a Worker or Reviewer to choose a blocked terminal outcome.