agents-relay 2.0.132 → 2.0.133

package/dist/cli-help.js

@@ -160,7 +160,8 @@ Required: the normal Job storage options.`,
 Required: --task-id ID and the normal Job storage options.`,
     'task recover': `Retry one failed/blocked durable Task from its active automatic Troubleshooter without cancelling that recovery Task.
 
-Required: --task-id ID, --recovery-task-id TROUBLESHOOTER_ID, and the normal Job storage options. The recovery Task must be an active Troubleshooter whose parentTaskId is the original Task.`,
+Required: --task-id ID, --recovery-task-id TROUBLESHOOTER_ID, and the normal Job storage options.
+Optional: --failure-kind adapter_failure|model_failure|provider_failure|task_failure|unknown --reason TEXT [--evidence TEXT] [--reroute] [--exclude-current-route]. Routing changes are atomic with recovery. The recovery Task must be an active Troubleshooter whose parentTaskId is the original Task.`,
     'task cancel': `Cancel one durable Task.
 
 Required: --task-id ID and the normal Job storage options.`,

package/dist/cli.js

@@ -70,6 +70,18 @@ async function runManagedTaskCommand(action, args) {
         throw new Error(`Task ${id} missing after ${action}`);
     console.log(JSON.stringify(task, null, 2));
 }
+function recoveryDiagnosisFromArgs(args) {
+    const failureKind = arg(args, '--failure-kind');
+    if (!failureKind)
+        return undefined;
+    const reason = arg(args, '--reason');
+    if (!reason.trim())
+        throw new Error('--failure-kind requires --reason');
+    if (!['adapter_failure', 'model_failure', 'provider_failure', 'task_failure', 'unknown'].includes(failureKind))
+        throw new Error('Invalid --failure-kind');
+    const reroute = args.includes('--reroute');
+    return { failureKind, reason, evidence: arg(args, '--evidence') || undefined, reroute, excludeCurrentRoute: args.includes('--exclude-current-route') };
+}
 async function runTaskCommand(action, args) {
     if (!['create', 'update', 'show', 'context', 'comment', 'comments', 'list', 'retry', 'recover', 'unblock', 'escalate', 'resume-troubleshooter', 'cancel', 'supersede'].includes(action))
         throw new Error(usage);
@@ -136,7 +148,7 @@ async function runTaskCommand(action, args) {
             const recoveryTaskId = arg(args, '--recovery-task-id');
             if (!recoveryTaskId)
                 throw new Error('task recover requires --recovery-task-id');
-            const job = await relayControlCommand(args, { command: 'task.recover', jobId, taskId, recoveryTaskId });
+            const job = await relayControlCommand(args, { command: 'task.recover', jobId, taskId, recoveryTaskId, recoveryDiagnosis: recoveryDiagnosisFromArgs(args) });
             console.log(JSON.stringify(job.tasks.find(item => item.id === taskId), null, 2));
             return;
         }
@@ -271,7 +283,7 @@ async function runTaskCommand(action, args) {
             const recoveryTaskId = action === 'recover' ? arg(args, '--recovery-task-id') : '';
             if (action === 'recover' && !recoveryTaskId)
                 throw new Error('task recover requires --recovery-task-id');
-            const result = await dispatchTaskAction(store, { id: action === 'recover' ? 'task.recover' : 'task.retry', jobId: job.id, taskId: id, ...(recoveryTaskId ? { recoveryTaskId } : {}) });
+            const result = await dispatchTaskAction(store, { id: action === 'recover' ? 'task.recover' : 'task.retry', jobId: job.id, taskId: id, ...(recoveryTaskId ? { recoveryTaskId, recoveryDiagnosis: recoveryDiagnosisFromArgs(args) } : {}) });
             if (result.job.state === 'DRAFT') {
                 await applyJobActivateAction(result.job);
                 await store.saveJob(result.job);

package/dist/reconciler-review.js

@@ -301,7 +301,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const routed = await routeExecution(candidates, requirements, {
             decisionEngine: this.options.decisionEngine,
             decisionMode: this.options.decisionMode,
-            taskFacts: { ...taskFacts, recovery_parent_failed_route: excludedRoutes[0] ?? null },
+            taskFacts: { ...taskFacts, recovery: task.recoveryContext ?? null, recovery_parent_failed_route: excludedRoutes[0] ?? null },
             usage,
             registered,
             chatgptRunning: runtimeSummary?.chatgptRunning ?? 0,

package/dist/relayd-control.js

@@ -158,7 +158,7 @@ export function createWorkspaceControl(deps) {
             const recoveryTaskId = typeof body.recoveryTaskId === 'string' ? body.recoveryTaskId : '';
             if (!taskId || !recoveryTaskId)
                 throw new Error('task recover requires taskId and recoveryTaskId');
-            await dispatchTaskAction(store, { id: 'task.recover', jobId, taskId, recoveryTaskId });
+            await dispatchTaskAction(store, { id: 'task.recover', jobId, taskId, recoveryTaskId, recoveryDiagnosis: body.recoveryDiagnosis });
             await pool.reconcileLocalJob(jobId, 'control.task.recover');
             return await store.load(jobId);
         }

package/dist/task-actions.js

@@ -156,6 +156,28 @@ export async function supersedeCancelledTask(store, jobId, taskId, reason) {
     await store.saveTask(task);
     return { job: await store.load(jobId), task };
 }
+function recordRecoveryRouting(task, request) {
+    const diagnosis = request.recoveryDiagnosis;
+    if (!diagnosis)
+        return;
+    if (!['adapter_failure', 'model_failure', 'provider_failure', 'task_failure', 'unknown'].includes(diagnosis.failureKind))
+        throw new Error('Invalid recovery failureKind');
+    if (!diagnosis.reason.trim())
+        throw new Error('Recovery diagnosis requires reason');
+    if (diagnosis.excludeCurrentRoute && !diagnosis.reroute)
+        throw new Error('Cannot exclude route without reroute');
+    if (diagnosis.excludeCurrentRoute && task.routing) {
+        const route = task.routing;
+        if (!task.routingExclusions?.some(item => item.provider === route.provider && item.model === route.model && item.profile === route.profile)) {
+            task.routingExclusions = [...(task.routingExclusions ?? []), { provider: route.provider, model: route.model, ...(route.profile ? { profile: route.profile } : {}), reason: diagnosis.reason, at: new Date().toISOString() }];
+        }
+    }
+    task.recoveryContext = { failureKind: diagnosis.failureKind, reason: diagnosis.reason, ...(diagnosis.evidence ? { evidence: diagnosis.evidence } : {}), recoveryTaskId: request.recoveryTaskId, at: new Date().toISOString(), reroute: diagnosis.reroute };
+    if (diagnosis.reroute) {
+        task.routing = undefined;
+        task.workerSelection = undefined;
+    }
+}
 /** Compatibility bridge: domain mutation only; adapters own wake/reconcile/output behavior. */
 export async function dispatchTaskAction(store, request) {
     if (store.mutateJob && [TASK_RETRY_ACTION, TASK_RECOVER_ACTION, TASK_CANCEL_ACTION].includes(request.id)) {
@@ -177,7 +199,7 @@ export async function dispatchTaskAction(store, request) {
             }
             else if (request.id === TASK_RECOVER_ACTION) {
                 const proposal = { path: 'exact_original_retry', targetTaskId: task.id, rootCause: task.failureReason ?? task.error ?? 'durable failure', solution: `Recover exact original Task via ${request.recoveryTaskId}` };
-                const decision = dispatchTaskResolutionSync(task, proposal, 'troubleshooter', { activateRecovery: () => { applyTaskRetrySnapshot(task, { extendBudget: true }); task.resolution = { ...materializeResolution(task, proposal, 'troubleshooter'), state: 'resolved' }; } });
+                const decision = dispatchTaskResolutionSync(task, proposal, 'troubleshooter', { activateRecovery: () => { applyTaskRetrySnapshot(task, { extendBudget: true }); recordRecoveryRouting(task, request); task.resolution = { ...materializeResolution(task, proposal, 'troubleshooter'), state: 'resolved' }; } });
                 if (!decision.accepted)
                     throw new Error(`Task resolution graph rejected exact-original recovery for ${task.id}`);
             }
@@ -211,7 +233,7 @@ export async function dispatchTaskAction(store, request) {
         if (!recovery || recovery.agentName !== 'troubleshooter' || recovery.parentTaskId !== task.id || !['QUEUED', 'RUNNING'].includes(recovery.state))
             throw new Error(`task recover requires an active Troubleshooter recovery for ${task.id}`);
         const proposal = { path: 'exact_original_retry', targetTaskId: task.id, rootCause: task.failureReason ?? task.error ?? 'durable failure', solution: `Recover exact original Task via ${request.recoveryTaskId}` };
-        const decision = dispatchTaskResolutionSync(task, proposal, 'troubleshooter', { activateRecovery: () => { applyTaskRetrySnapshot(task, { extendBudget: true }); task.resolution = { ...materializeResolution(task, proposal, 'troubleshooter'), state: 'resolved' }; } });
+        const decision = dispatchTaskResolutionSync(task, proposal, 'troubleshooter', { activateRecovery: () => { applyTaskRetrySnapshot(task, { extendBudget: true }); recordRecoveryRouting(task, request); task.resolution = { ...materializeResolution(task, proposal, 'troubleshooter'), state: 'resolved' }; } });
         if (!decision.accepted)
             throw new Error(`Task resolution graph rejected exact-original recovery for ${task.id}`);
     }

package/dist/troubleshooter.js

@@ -26,7 +26,7 @@ Retrieve this task's lifecycle event history before classifying the root cause o
 GET http://127.0.0.1:8787/api/events?job=${encodeURIComponent(job.id)}&task=${encodeURIComponent(task.id)}&limit=200
 Inspect event order, type/status, source, data/phase, duplicate events, missing expected lifecycle events, late events, and execution identifiers. If the event stream points to delivery/runtime failure, inspect the corresponding Relay/worker/tool logs too. Do not treat the final task.error string as the complete root cause.
 
-Follow the selected Troubleshooter agent contract. Diagnose root cause from durable task state + event history + relevant runtime logs before retry. The final task.error string alone is never sufficient. Classify the evidence as model/provider/runtime, worker/tool/infrastructure, semantic task failure, or timeout/unknown. Select exactly one graph-enabled resolution path: exact_original_retry, same_job_dependency, blocker_job_dependency (with merge or verified mode), escalation_gate, or cancel_supersede. Only model/provider/runtime evidence may call the narrow model re-decision action; that action gathers fresh usage, reloads current policy, updates this exact Task's routing, and does not retry it. Troubleshooter must then reactivate/retry this exact original task and verify progress. Use the dedicated agents-relay task recover path with --task-id ${task.id} and --recovery-task-id ${recoveryId}; never use ordinary task retry from a Troubleshooter because manual retry intentionally supersedes active recovery. Do not manually choose a provider/model or create a replacement task; no replacement_task action exists. If the blocker is a shared worker/runtime/tool defect, create and directly complete a P0/self-job in the owning repository, including required release/deploy verification. If diagnosis suggests a genuine human/external blocker, do not publish task.blocked directly and do not implement the result branch procedurally. Call agents-relay escalation with the original intent, blocker, and relevant context. Pass any caller-defined notification plan through --on-needs-user/--on-needs-user-file; do not hard-code a channel. The canonical escalation graph invokes Neo escalation and owns the resolved/failed/needs_user branch; follow its selected outcome. Retry this exact original task only after the blocker is removed, reconcile the original job, and verify durable progress.`;
+Follow the selected Troubleshooter agent contract. Diagnose root cause from durable task state + event history + relevant runtime logs before retry. The final task.error string alone is never sufficient. Classify the evidence as model/provider/runtime, worker/tool/infrastructure, semantic task failure, or timeout/unknown. Select exactly one graph-enabled resolution path: exact_original_retry, same_job_dependency, blocker_job_dependency (with merge or verified mode), escalation_gate, or cancel_supersede. For confirmed adapter/model/provider failure, include --failure-kind, --reason, --evidence and --reroute in task recover; use --exclude-current-route only if the exact failed route should not be selected again. For semantic task failure use --failure-kind task_failure without rerouting. For uncertain failures use --failure-kind unknown and preserve routing unless evidence justifies rerouting. The recovery transaction stores diagnosis, clears old routing only on request, and next execution automatically reroutes with the evidence and exclusions. Troubleshooter must then reactivate/retry this exact original task and verify progress. Use the dedicated agents-relay task recover path with --task-id ${task.id} and --recovery-task-id ${recoveryId}; never use ordinary task retry from a Troubleshooter because manual retry intentionally supersedes active recovery. Do not manually choose a provider/model or create a replacement task; no replacement_task action exists. If the blocker is a shared worker/runtime/tool defect, create and directly complete a P0/self-job in the owning repository, including required release/deploy verification. If diagnosis suggests a genuine human/external blocker, do not publish task.blocked directly and do not implement the result branch procedurally. Call agents-relay escalation with the original intent, blocker, and relevant context. Pass any caller-defined notification plan through --on-needs-user/--on-needs-user-file; do not hard-code a channel. The canonical escalation graph invokes Neo escalation and owns the resolved/failed/needs_user branch; follow its selected outcome. Retry this exact original task only after the blocker is removed, reconcile the original job, and verify durable progress.`;
 }
 function belongsToCurrentRun(job, task) {
     const slot = job.schedule?.currentRunSlot;

package/package.json

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