agents-relay 1.0.102 → 1.0.104

package/dist/reconciler-runtime.js

@@ -1,4 +1,5 @@
 import { transitionJobEvent, transitionTaskEvent } from './scheduler.js';
+import { DurableTaskTransitionRuntime } from './workflow/durable-transition.js';
 import { StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
 import { WorkflowEffectExecutor } from './workflow/effects.js';
@@ -24,11 +25,13 @@ export class ReconcilerRuntimeBase {
     continuationLive = new Set();
     launchFailureClaims = new Set();
     terminalWaiters = new Map();
+    taskTransitions;
     workflowEffects = new WorkflowEffectExecutor();
     reconciling = false;
     constructor(store, options) {
         this.store = store;
         this.options = options;
+        this.taskTransitions = new DurableTaskTransitionRuntime(store);
     }
     async applyJobEffectOutcomes(job, outcomes) {
         for (const outcome of outcomes.filter(item => item.status === 'failed')) {
@@ -158,32 +161,28 @@ export class ReconcilerRuntimeBase {
         const live = this.live.get(event.task_id);
         if (live && event.job_id === live.jobId && event.timestamp && new Date(event.timestamp).getTime() < live.launchBarrier)
             return;
-        const job = await this.store.load(event.job_id);
-        const task = job.tasks.find(item => item.id === event.task_id);
-        if (!task || !task.executionId || eventSourceId(event) !== executionEventSource(job.id, task.id, task.executionId))
-            return;
-        const claimedExecution = task.state === 'QUEUED' && task.executionId !== null && task.leaseOwner !== null;
-        const exactLiveExecution = live && event.job_id === live.jobId && task.executionId === live.executionId;
-        if ((exactLiveExecution || claimedExecution) && task.state === 'QUEUED') {
-            await transitionTaskEvent(task, 'task.started');
-            task.failureReason = undefined;
-            task.error = null;
-            task.updatedAt = event.timestamp || new Date().toISOString();
-            await this.store.saveTask(task);
-            if (live)
-                live.workerStarted = true;
-            return;
-        }
-        if (task.state !== 'FAILED' || !this.isRecoverableWatchdogFailure(task))
-            return;
-        if (event.timestamp && new Date(event.timestamp).getTime() < new Date(task.updatedAt).getTime())
+        const transition = await this.taskTransitions.apply(event.job_id, event.task_id, 'task.started', {
+            eligible: (job, task) => {
+                if (!task.executionId || eventSourceId(event) !== executionEventSource(job.id, task.id, task.executionId))
+                    return false;
+                const claimedExecution = task.executionId !== null && task.leaseOwner !== null;
+                const exactLiveExecution = live && event.job_id === live.jobId && task.executionId === live.executionId;
+                return Boolean(exactLiveExecution || claimedExecution || this.isRecoverableWatchdogFailure(task));
+            },
+            facts: (_job, task) => ({
+                recoverableExecution: this.isRecoverableWatchdogFailure(task)
+                    && (!event.timestamp || new Date(event.timestamp).getTime() >= new Date(task.updatedAt).getTime()),
+            }),
+            mutate: (_job, task) => {
+                task.updatedAt = event.timestamp || new Date().toISOString();
+            },
+        });
+        if (!transition?.decision.accepted)
             return;
-        await transitionTaskEvent(task, 'reconcile.started');
-        task.failureReason = undefined;
-        task.error = null;
-        task.updatedAt = event.timestamp || new Date().toISOString();
-        await this.store.saveTask(task);
-        this.detach(this.reconcile(job.id), job.id, task.id, 'late worker-start reconciliation');
+        if (live?.executionId === transition.task.executionId)
+            live.workerStarted = true;
+        if (transition.from === 'FAILED')
+            this.detach(this.reconcile(event.job_id), event.job_id, event.task_id, 'late worker-start reconciliation');
     }
     isRecoverableWatchdogFailure(task) {
         if (['worker_start_timeout', 'terminal_event_timeout', 'worker_exit_before_start', 'worker_exit_without_terminal_event', 'worker_delivery_after_start'].includes(task.failureReason ?? ''))
@@ -205,23 +204,25 @@ export class ReconcilerRuntimeBase {
         this.launchFailureClaims.add(claim);
         const cleanup = setTimeout(() => this.launchFailureClaims.delete(claim), 60000);
         cleanup.unref();
-        const job = await this.store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        if (!task || task.executionId !== executionId || !['QUEUED', 'RUNNING'].includes(task.state))
+        const workflowEvent = phase === 'start-ack' ? 'worker.start_ack_failed' : 'worker.delivery_failed';
+        const transition = await this.taskTransitions.apply(jobId, taskId, workflowEvent, {
+            eligible: (_job, task) => task.executionId === executionId,
+            mutate: (_job, task) => {
+                this.clearExecution(task.id, executionId);
+                task.error = `Worker ${phase} failed: ${message}`;
+                task.failureReason = phase === 'start-ack' ? 'worker_start_timeout' : undefined;
+                task.leaseOwner = null;
+                task.leaseExpiresAt = null;
+            },
+        });
+        if (!transition)
             return;
-        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' }));
+        if (!transition.decision.accepted) {
+            await this.emit(eventFor(jobId, taskId, transition.task.parentTaskId, 'task.process.delivery_failed', 'failed', `Worker ${phase} reported after lifecycle moved to ${transition.from}: ${message}`, 'orchestrator', { phase, authoritative: false, executionId, workflowEvent }, { 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);
+        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? `Worker ${phase} failed: ${message}`, 'user', { phase, reason: transition.task.failureReason, workflowEvent }, { agent: 'relay', component: 'agents-relay', watchdog: true });
+        this.detach(this.emit(event), jobId, taskId, 'worker failure event');
     }
     async runtimeSettled(jobId, taskId, executionId, result, error) {
         const live = this.live.get(taskId);
@@ -234,7 +235,7 @@ export class ReconcilerRuntimeBase {
         if (!task || task.executionId !== executionId)
             return;
         await this.emit(eventFor(jobId, taskId, task.parentTaskId, task.adapter === 'chatgpt' ? 'task.process.async_exited' : 'task.process.exited', error ? 'failed' : 'succeeded', error ?? result?.summary ?? 'Worker runtime exited', 'orchestrator', { authoritative: false, waitingForTerminalEvent: true, processError: error }, { agent: 'relay', component: 'agents-relay' }));
-        if (['QUEUED', 'RUNNING'].includes(task.state) && task.adapter === 'codex' && !terminalExecutionClaimed(jobId, taskId, executionId))
+        if (task.adapter === 'codex' && !terminalExecutionClaimed(jobId, taskId, executionId))
             this.scheduleUnexpectedExit(jobId, taskId, executionId, workerStarted === true);
     }
     scheduleUnexpectedExit(jobId, taskId, executionId, workerStarted) {
@@ -248,28 +249,24 @@ export class ReconcilerRuntimeBase {
     async failUnexpectedExit(jobId, taskId, executionId, workerStarted) {
         if (terminalExecutionClaimed(jobId, taskId, executionId))
             return;
-        const job = await this.store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        if (!task || task.executionId !== executionId || !['QUEUED', 'RUNNING'].includes(task.state) || terminalExecutionClaimed(jobId, taskId, executionId))
-            return;
         const reason = workerStarted ? 'worker_exit_without_terminal_event' : 'worker_exit_before_start';
         const message = workerStarted
             ? `Worker ${taskId} exited after task.started without publishing a terminal task event`
             : `Worker ${taskId} exited before publishing task.started`;
-        const event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', message, 'user', { reason, terminalGraceMs: this.options.terminalExitGraceMs ?? 1000 }, { agent: 'relay', component: 'agents-relay', watchdog: true });
-        if (task.state === 'QUEUED') {
-            this.clearExecution(task.id, executionId);
-            task.error = message;
-            task.failureReason = reason;
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            await transitionTaskEvent(task, 'fail');
-            await this.store.saveTask(task);
-        }
-        else {
-            await this.applyTerminalEvent(event, true);
-        }
-        await this.emit(event);
+        const transition = await this.taskTransitions.apply(jobId, taskId, 'watchdog.failed', {
+            eligible: (_job, task) => task.executionId === executionId && !terminalExecutionClaimed(jobId, taskId, executionId),
+            mutate: (_job, task) => {
+                this.clearExecution(task.id, executionId);
+                task.error = message;
+                task.failureReason = reason;
+                task.leaseOwner = null;
+                task.leaseExpiresAt = null;
+            },
+        });
+        if (!transition?.decision.accepted)
+            return;
+        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', message, 'user', { reason, terminalGraceMs: this.options.terminalExitGraceMs ?? 1000, workflowEvent: 'watchdog.failed' }, { agent: 'relay', component: 'agents-relay', watchdog: true });
+        this.detach(this.emit(event), jobId, taskId, 'watchdog failure event');
     }
     async timeoutTask(jobId, taskId, executionId) {
         const live = this.live.get(taskId);
@@ -277,81 +274,74 @@ export class ReconcilerRuntimeBase {
             live.controller.abort();
             live.execution.cancel();
         }
-        const job = await this.store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        if (!task || task.executionId !== executionId || !['QUEUED', 'RUNNING'].includes(task.state)) {
+        const transition = await this.taskTransitions.apply(jobId, taskId, 'watchdog.failed', {
+            eligible: (_job, task) => task.executionId === executionId,
+            mutate: (_job, task) => {
+                this.clearExecution(task.id, executionId);
+                task.error = `Task ${taskId} timed out waiting for the mandatory terminal worker event`;
+                task.failureReason = 'terminal_event_timeout';
+                task.leaseOwner = null;
+                task.leaseExpiresAt = null;
+            },
+        });
+        if (!transition?.decision.accepted) {
             this.clearExecution(taskId, executionId);
             return;
         }
-        const event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', `Task ${taskId} timed out waiting for the mandatory terminal worker event`, 'user', { reason: 'terminal_event_timeout', timeoutMs: task.timeoutMs });
-        if (task.state === 'QUEUED') {
-            task.error = event.message;
-            task.failureReason = 'terminal_event_timeout';
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            await transitionTaskEvent(task, 'fail');
-            await this.store.saveTask(task);
-            this.clearExecution(task.id, executionId);
-        }
-        else {
-            await this.applyTerminalEvent(event, true);
-        }
-        await this.emit(event);
+        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? `Task ${taskId} timed out waiting for the mandatory terminal worker event`, 'user', { reason: 'terminal_event_timeout', timeoutMs: transition.task.timeoutMs, workflowEvent: 'watchdog.failed' }, { agent: 'relay', component: 'agents-relay', watchdog: true });
+        this.detach(this.emit(event), jobId, taskId, 'timeout failure event');
     }
     async applyTerminalEvent(event, trustedInternal = false) {
-        const job = await this.store.load(event.job_id);
-        const task = job.tasks.find(item => item.id === event.task_id);
-        if (!task || !['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
-            return;
-        const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
-        if (!trustedInternal && modelBacked && !this.isCorrelatedWorkerEvent(task, event))
-            return;
-        if (task.state === 'FAILED' && this.isRecoverableWatchdogFailure(task) && (trustedInternal || !modelBacked || this.isCorrelatedWorkerEvent(task, event))) {
-            if (event.timestamp && new Date(event.timestamp).getTime() < new Date(task.updatedAt).getTime())
-                return;
-            await transitionTaskEvent(task, 'reconcile.started');
-            task.failureReason = undefined;
-            task.error = null;
-        }
-        if (task.state !== 'RUNNING')
-            return;
-        const terminalWaiter = this.terminalWaiters.get(task.id);
-        if (terminalWaiter && (!event.timestamp || new Date(event.timestamp).getTime() < terminalWaiter.launchBarrier))
+        const transition = await this.taskTransitions.apply(event.job_id, event.task_id, event.type, {
+            eligible: (_job, task) => {
+                if (!['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
+                    return false;
+                const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
+                if (!trustedInternal && modelBacked && !this.isCorrelatedWorkerEvent(task, event))
+                    return false;
+                const terminalWaiter = this.terminalWaiters.get(task.id);
+                return !terminalWaiter || Boolean(event.timestamp && new Date(event.timestamp).getTime() >= terminalWaiter.launchBarrier);
+            },
+            facts: (_job, task) => {
+                const processExitedAfterPublishedTerminal = task.failureReason === 'worker_exit_without_terminal_event';
+                const freshEnough = processExitedAfterPublishedTerminal
+                    || !event.timestamp
+                    || new Date(event.timestamp).getTime() >= new Date(task.updatedAt).getTime();
+                return { recoverableExecution: this.isRecoverableWatchdogFailure(task) && freshEnough };
+            },
+            mutate: (job, task) => {
+                const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
+                const acceptedExecutionId = task.executionId;
+                if (modelBacked && acceptedExecutionId)
+                    claimTerminalExecution(executionEventSource(job.id, task.id, acceptedExecutionId));
+                this.clearExecution(task.id, acceptedExecutionId);
+                task.leaseOwner = null;
+                task.leaseExpiresAt = null;
+                task.updatedAt = event.timestamp || new Date().toISOString();
+                this.terminalWaiters.get(task.id)?.resolve();
+                this.terminalWaiters.delete(task.id);
+                if (event.type === 'task.completed') {
+                    task.result = { summary: event.message || `Task ${task.id} completed`, data: event.data };
+                    task.error = null;
+                    task.failureReason = undefined;
+                }
+                else if (event.type === 'task.failed') {
+                    task.error = event.message || `Task ${task.id} failed`;
+                    task.failureReason = typeof event.data?.reason === 'string' ? event.data.reason : undefined;
+                }
+                else if (event.type === 'task.blocked') {
+                    task.error = event.message || `Task ${task.id} blocked`;
+                }
+                else if (event.type === 'task.cancelled') {
+                    task.error = event.message || `Task ${task.id} cancelled`;
+                }
+            },
+        });
+        if (!transition?.decision.accepted)
             return;
-        const acceptedExecutionId = task.executionId;
-        if (modelBacked && acceptedExecutionId)
-            claimTerminalExecution(executionEventSource(job.id, task.id, acceptedExecutionId));
-        this.clearExecution(task.id, acceptedExecutionId);
-        task.leaseOwner = null;
-        task.leaseExpiresAt = null;
-        task.updatedAt = event.timestamp || new Date().toISOString();
-        this.terminalWaiters.get(task.id)?.resolve();
-        this.terminalWaiters.delete(task.id);
-        if (event.type === 'task.completed') {
-            task.result = { summary: event.message || `Task ${task.id} completed`, data: event.data };
-            task.error = null;
-            task.failureReason = undefined;
-            await transitionTaskEvent(task, 'task.completed');
-            await this.store.saveTask(task);
-            await this.deliverContinuation(job, task);
-        }
-        else if (event.type === 'task.failed') {
-            task.error = event.message || `Task ${task.id} failed`;
-            task.failureReason = typeof event.data?.reason === 'string' ? event.data.reason : undefined;
-            await transitionTaskEvent(task, 'task.failed');
-            await this.store.saveTask(task);
-        }
-        else if (event.type === 'task.blocked') {
-            task.error = event.message || `Task ${task.id} blocked`;
-            await transitionTaskEvent(task, 'task.blocked');
-            await this.store.saveTask(task);
-        }
-        else if (event.type === 'task.cancelled') {
-            task.error = event.message || `Task ${task.id} cancelled`;
-            await transitionTaskEvent(task, 'task.cancelled');
-            await this.store.saveTask(task);
-        }
-        this.detach(this.reconcile(job.id), job.id, task.id, 'terminal-event reconciliation');
+        if (event.type === 'task.completed')
+            await this.deliverContinuation(transition.job, transition.task);
+        this.detach(this.reconcile(transition.job.id), transition.job.id, transition.task.id, 'terminal-event reconciliation');
     }
     terminalWait(taskId, executionId, launchBarrier) {
         let resolve;

package/dist/reconciler.js

@@ -6,11 +6,12 @@ import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
 import { parsePlannerResult, plannerInput } from './planner.js';
 import { agentContractPrompt, executionContextPrompt, resolveExecutionContext } from './execution-context.js';
-import { agentGraphPrompt } from './agent-graph.js';
+import { agentGraphPrompt, validateAgentSelection } from './agent-graph.js';
 import { ReconcilerReviewBase } from './reconciler-review.js';
 import { executionEventSource } 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';
 const PRIORITY_RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
@@ -114,8 +115,7 @@ export class Reconciler extends ReconcilerReviewBase {
                 if (job.state !== terminalState) {
                     if (!['DRAFT', 'ACTIVE', 'COMPLETED', 'CANCELLED'].includes(job.state)) {
                         // Compatibility repair boundary for historical records that persisted runtime status as lifecycle.
-                        job.state = terminalState;
-                        job.updatedAt = new Date().toISOString();
+                        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);
@@ -289,8 +289,12 @@ export class Reconciler extends ReconcilerReviewBase {
         return this.store.load(job.id);
     }
     async recoverPlannerChildren(job) {
+        const contextTask = job.tasks.find(task => task.kind === 'planner') ?? job.tasks[0];
+        if (!contextTask)
+            return;
+        const executionContext = await this.resolvedContext(job, contextTask, 'planner');
         for (const planner of job.tasks.filter(task => task.kind === 'planner' && task.state === 'SUCCEEDED' && task.plannerResult)) {
-            const children = planner.plannerResult?.next_tasks.map(spec => this.plannerChild(job, planner, spec)) ?? [];
+            const children = planner.plannerResult?.next_tasks.map(spec => this.plannerChild(job, planner, spec, executionContext)) ?? [];
             for (const child of children) {
                 const existing = job.tasks.find(item => item.id === child.id);
                 if (existing) {
@@ -475,7 +479,8 @@ export class Reconciler extends ReconcilerReviewBase {
         }
         try {
             const result = parsePlannerResult(raw);
-            const children = result.next_tasks.map(spec => this.plannerChild(job, task, spec));
+            const executionContext = await this.resolvedContext(job, task, 'planner');
+            const children = result.next_tasks.map(spec => this.plannerChild(job, task, spec, executionContext));
             for (const child of children) {
                 const existing = job.tasks.find(item => item.id === child.id);
                 if (!existing)
@@ -516,7 +521,8 @@ export class Reconciler extends ReconcilerReviewBase {
         }
         this.detach(this.reconcile(jobId), jobId, task.id, 'planner follow-up reconciliation');
     }
-    plannerChild(job, planner, spec) {
+    plannerChild(job, planner, spec, executionContext) {
+        validateAgentSelection(executionContext, spec.agentName, spec.agentGraph);
         const now = new Date().toISOString();
         return { jobId: job.id, id: spec.id, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, agentGraph: spec.agentGraph, parentTaskId: planner.id, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: spec.workerRequirements, adapter: 'codex', input: spec.input, output: spec.output, continuation: spec.continuation ?? null, continuationDeliveredAt: null, state: (spec.dependencies?.length ?? 0) > 0 ? 'DRAFT' : 'QUEUED', attempt: 0, maxAttempts: spec.maxAttempts ?? 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: spec.timeoutMs ?? taskOverallTimeoutMs(spec.storySize ?? 'M'), createdAt: now, updatedAt: now, planningDecisionId: planner.id, planningSource: planner.planningSource ?? 'model-planner', planningRound: planner.planningRound ?? 1 };
     }

package/dist/relayd.js

@@ -16,6 +16,7 @@ import { codexAndZaiUsageRegistry } from './usage.js';
 import { defaultWorkspaceRoot, discoverWorkspaceRepositories, resolveManagedProjectPath } from './workspace.js';
 import { deriveJobRuntimeStatus } from './runtime-status.js';
 import { decisionMode, LayaCliDecisionEngine } from './decision.js';
+import { JsonlDecisionAuditStore } from './decision-audit.js';
 export const daemonHelp = `Agents Relay daemon runs the dashboard and worker pool.
 
 Usage:
@@ -72,7 +73,8 @@ export async function runDaemon(argv) {
     const repositoryPaths = new Map(discoveredRepositories.map(item => [item.repository, item.path]));
     const explicitProjectPath = value(argv, '--project-path');
     const usageRegistry = codexAndZaiUsageRegistry();
-    const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), usageSnapshotProvider: () => usageRegistry.snapshot(), decisionEngine: new LayaCliDecisionEngine(), decisionMode: decisionMode(), eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: job => repositoryPaths.get(job.repository) ?? resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot) });
+    const decisionAuditStore = new JsonlDecisionAuditStore(process.env.AGENTS_RELAY_DECISION_AUDIT_PATH ?? join(homedir(), '.agents-relay', 'decision-audit.jsonl'));
+    const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), usageSnapshotProvider: () => usageRegistry.snapshot(), decisionEngine: new LayaCliDecisionEngine(), decisionMode: decisionMode(), decisionAuditStore, eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: job => repositoryPaths.get(job.repository) ?? resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot) });
     if (repositories.length === 0)
         throw new Error(`No Git repositories with GitHub origins found under ${normalized.workspaceRoot ?? defaultWorkspaceRoot()}`);
     const pool = new RepositoryWorkerPool(client, repositories, trusted, concurrency, makeReconciler);

package/dist/routing-policy.js

@@ -0,0 +1,75 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+const EMPTY_POLICY = {};
+function safePolicy(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const source = value;
+    const strings = (item) => Array.isArray(item) && item.every(value => typeof value === 'string') ? [...item] : undefined;
+    const result = {};
+    result.disabledProfiles = strings(source.disabledProfiles);
+    result.disabledProviders = strings(source.disabledProviders);
+    result.preferredProviders = strings(source.preferredProviders);
+    result.preferredProfiles = strings(source.preferredProfiles);
+    if (source.qualityByTaskKind && typeof source.qualityByTaskKind === 'object' && !Array.isArray(source.qualityByTaskKind)) {
+        result.qualityByTaskKind = {};
+        for (const [key, value] of Object.entries(source.qualityByTaskKind)) {
+            const parsed = strings(value);
+            if (parsed)
+                result.qualityByTaskKind[key] = parsed;
+        }
+    }
+    if (source.recovery && typeof source.recovery === 'object' && !Array.isArray(source.recovery)) {
+        const penalize = source.recovery.penalizePriorRoute;
+        if (typeof penalize === 'boolean')
+            result.recovery = { penalizePriorRoute: penalize };
+    }
+    return result;
+}
+export function policyPath(explicit) {
+    return explicit ?? process.env.AGENTS_RELAY_ROUTING_POLICY ?? join(process.cwd(), '.agents-relay-routing-policy.json');
+}
+export function modelRouterRulesPath(explicit) {
+    return explicit ?? process.env.AGENTS_RELAY_MODEL_ROUTER_RULES ?? join(process.cwd(), '.agents-relay-model-router-rules.md');
+}
+export async function loadModelRouterRules(explicit) {
+    const path = modelRouterRulesPath(explicit);
+    try {
+        const text = await readFile(path, 'utf8');
+        return { path, hash: createHash('sha256').update(text).digest('hex'), text };
+    }
+    catch {
+        return { path, hash: 'none', text: '' };
+    }
+}
+export async function saveModelRouterRules(text, explicit) {
+    const path = modelRouterRulesPath(explicit);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, text, 'utf8');
+    return { path, hash: createHash('sha256').update(text).digest('hex'), text };
+}
+export async function loadRoutingPolicy(explicit, explicitRules) {
+    const path = policyPath(explicit);
+    const rules = await loadModelRouterRules(explicitRules);
+    try {
+        const text = await readFile(path, 'utf8');
+        const policy = safePolicy(JSON.parse(text));
+        return { path, hash: createHash('sha256').update(text).digest('hex'), policy, snapshot: JSON.parse(JSON.stringify(policy)), rules };
+    }
+    catch {
+        return { path: null, hash: 'none', policy: EMPTY_POLICY, snapshot: {}, rules };
+    }
+}
+export function policyAllows(candidate, policy) {
+    if (policy.disabledProviders?.includes(candidate.provider))
+        return false;
+    if (candidate.profile && policy.disabledProfiles?.includes(candidate.profile))
+        return false;
+    return true;
+}
+export function policyRank(candidate, taskKind, policy) {
+    const preferred = new Set([...(policy.preferredProviders ?? []), ...(policy.preferredProfiles ?? [])]);
+    const quality = taskKind ? new Set(policy.qualityByTaskKind?.[taskKind] ?? []) : new Set();
+    return (preferred.has(candidate.provider) || (candidate.profile && preferred.has(candidate.profile)) ? 2 : 0) + (quality.has(candidate.id) ? 1 : 0);
+}

package/dist/runtime-status.js

@@ -46,6 +46,8 @@ export function deriveJobRuntimeStatus(job, prState = 'OPEN') {
         return 'FAILED';
     if (job.tasks.some(task => task.state === 'DRAFT'))
         return 'WAITING';
+    if (job.executionMode === 'autonomous' && job.autoMerge === false && job.reviewEnabled === false && implementationComplete(job) && prState === 'OPEN')
+        return 'WAITING';
     if (job.reviewEnabled === false && implementationComplete(job) && prState === 'OPEN')
         return 'MERGE_PENDING';
     return 'IDLE';

package/dist/scheduler.js

@@ -35,13 +35,19 @@ export function extendRetryBudget(task, windowSize = 3) {
     const usedOrBudgeted = Math.max(task.maxAttempts, task.attempt);
     return Math.max(windowSize, (Math.floor(usedOrBudgeted / windowSize) + 1) * windowSize);
 }
-export async function transitionTaskEvent(task, event, context = {}) {
+export function tryTransitionTaskEvent(task, event, context = {}) {
     const decision = decideTaskLifecycle(task, event, context);
+    if (decision.accepted && decision.target)
+        applyTaskWorkflowDecision(task, decision);
+    return decision;
+}
+export async function transitionTaskEvent(task, event, context = {}) {
+    const from = task.state;
+    const decision = tryTransitionTaskEvent(task, event, context);
     if (!decision.accepted || !decision.target)
         throw new Error(decision.reason === 'ambiguous'
-            ? `Ambiguous workflow transition from ${task.state} on ${event}`
-            : `No enabled workflow transition from ${task.state} on ${event}`);
-    applyTaskWorkflowDecision(task, decision);
+            ? `Ambiguous workflow transition from ${from} on ${event}`
+            : `No enabled workflow transition from ${from} on ${event}`);
     return decision;
 }
 export async function transitionJobEvent(job, event, context = {}) {

package/dist/troubleshooter.js

@@ -24,7 +24,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. 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. 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. 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. Do not manually choose a provider/model or create a replacement task. 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. 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/dist/worker-routing.js

@@ -1,9 +1,31 @@
 import { chooseWithDecision } from './decision.js';
-export function usageForProvider(snapshot, provider) {
+export function usageForProvider(snapshot, provider, now = Date.now()) {
     const usage = snapshot?.providers.find(item => item.id === provider)?.usage;
     if (usage?.available) {
         const usedPercent = Math.max(usage.fiveHour?.usedPercent ?? 0, usage.weekly?.usedPercent ?? 0);
-        return { healthy: usedPercent < 100, usedPercent };
+        const resourceWindow = (window) => {
+            if (!window)
+                return undefined;
+            const resetAt = window.resetsAt;
+            return {
+                remainingPercent: 100 - window.usedPercent,
+                resetAt,
+                resetInMinutes: resetAt === null ? null : Math.max(0, Math.ceil((resetAt * 1000 - now) / 60_000)),
+            };
+        };
+        const windows = { fiveHour: resourceWindow(usage.fiveHour), weekly: resourceWindow(usage.weekly) };
+        const resetWindow = [usage.fiveHour, usage.weekly]
+            .filter((window) => window?.resetsAt !== null && window?.resetsAt !== undefined)
+            .filter(window => window.resetsAt * 1000 > now)
+            .sort((left, right) => left.resetsAt - right.resetsAt)[0];
+        return {
+            healthy: usedPercent < 100,
+            usedPercent,
+            remainingPercent: resetWindow ? 100 - resetWindow.usedPercent : undefined,
+            resetAt: resetWindow?.resetsAt ?? undefined,
+            resetInMinutes: resetWindow?.resetsAt ? Math.max(0, Math.ceil((resetWindow.resetsAt * 1000 - now) / 60_000)) : undefined,
+            windows,
+        };
     }
     const credits = snapshot?.credits.find(item => item.id === provider)?.credits;
     if (credits?.available) {
@@ -34,6 +56,10 @@ export function workerCandidates(adapters, registered, snapshot) {
                 resourceHealthy: resource.healthy,
                 resourceProvider: provider,
                 resourceUsedPercent: resource.usedPercent,
+                resourceRemainingPercent: resource.remainingPercent,
+                resourceResetAt: resource.resetAt,
+                resourceResetInMinutes: resource.resetInMinutes,
+                resourceWindows: resource.windows,
             };
         });
     });
@@ -76,6 +102,10 @@ function selection(selected, selectedBy, decisionEvidence) {
         resourceHealthy: selected.resourceHealthy,
         resourceProvider: selected.resourceProvider,
         resourceUsedPercent: selected.resourceUsedPercent,
+        resourceRemainingPercent: selected.resourceRemainingPercent,
+        resourceResetAt: selected.resourceResetAt,
+        resourceResetInMinutes: selected.resourceResetInMinutes,
+        resourceWindows: selected.resourceWindows,
         decisionEvidence,
     };
 }
@@ -108,6 +138,10 @@ export async function routeWorker(candidates, requirements, options = {}) {
             resourceHealthy: item.resourceHealthy ?? null,
             resourceProvider: item.resourceProvider ?? null,
             resourceUsedPercent: item.resourceUsedPercent ?? null,
+            resourceRemainingPercent: item.resourceRemainingPercent ?? null,
+            resourceResetAt: item.resourceResetAt ?? null,
+            resourceResetInMinutes: item.resourceResetInMinutes ?? null,
+            resourceWindows: item.resourceWindows ?? null,
         })),
     }));
     const choice = await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', { facts }, { type: 'choice', question: 'Which eligible worker is best suited to execute this task?', choices: eligible.map(item => item.workerId) }, () => deterministic.workerId);

package/dist/workflow/contracts.js

@@ -12,9 +12,6 @@ export const WORKFLOW_EVENT_NAMES = [
     'pr.closed',
     'pr.merged',
     'reconcile',
-    'reconcile.blocked',
-    'reconcile.completed',
-    'reconcile.started',
     'release',
     'retry',
     'review.approved',
@@ -23,6 +20,9 @@ export const WORKFLOW_EVENT_NAMES = [
     'task.completed',
     'task.failed',
     'task.started',
+    'watchdog.failed',
+    'worker.delivery_failed',
+    'worker.start_ack_failed',
 ];
 export const WORKFLOW_FACT_NAMES = [
     'dependenciesSatisfied',
@@ -31,6 +31,7 @@ export const WORKFLOW_FACT_NAMES = [
     'dispatchable',
     'notMerged',
     'autoMerge',
+    'recoverableExecution',
 ];
 export const WORKFLOW_MUTATION_NAMES = [
     'mutation.clearError',

package/dist/workflow/definitions.js

@@ -33,4 +33,5 @@ export const taskLifecycleWorkflow = load('task-lifecycle', {
     dependenciesUnsatisfied: booleanGuard('dependenciesUnsatisfied'),
     runnable: booleanGuard('runnable'),
     dispatchable: booleanGuard('dispatchable'),
+    recoverableExecution: booleanGuard('recoverableExecution'),
 });