agents-relay 2.0.68 → 2.0.69

package/dist/reconciler-runtime.js

@@ -1,9 +1,9 @@
+import { applyJobEffectOutcomes, applyTaskEffectOutcomes } from './workflow-effect-failures.js';
+import { classifyWorkerRejection, reroutableWorkerRejections } from './worker-rejection.js';
 import { applyTaskRetryAction } from './task-actions.js';
-import { transitionJobEvent, transitionTaskEvent } from './scheduler.js';
 import { DurableTaskTransitionRuntime } from './workflow/durable-transition.js';
 import { eventFor } from './events.js';
 import { WorkflowEffectExecutor } from './workflow/effects.js';
-import { workflowEffectFailureEvent } from './workflow/contracts.js';
 import { ReconcileCoordinator } from './reconcile-coordinator.js';
 import { acceptedReportedTag, eventDataWithoutTag } from './task-tag.js';
 import { rearmTerminalEventDeadline } from './terminal-event-watchdog.js';
@@ -77,31 +77,10 @@ export class ReconcilerRuntimeBase {
         });
     }
     async applyJobEffectOutcomes(job, outcomes) {
-        for (const outcome of outcomes.filter(item => item.status === 'failed')) {
-            const eventName = workflowEffectFailureEvent(outcome.effect);
-            try {
-                await transitionJobEvent(job, eventName);
-                await this.store.saveJob(job);
-            }
-            catch {
-                // Some effects are observational for a given state; failure is still emitted below.
-            }
-            await this.emit(eventFor(job.id, 'job', null, 'workflow.effect.failed', 'failed', `${outcome.effect} failed: ${outcome.error ?? 'unknown error'}`, 'orchestrator', { effect: outcome.effect, idempotencyKey: outcome.key, workflowEvent: eventName }, { agent: 'relay', component: 'agents-relay' }));
-        }
+        await applyJobEffectOutcomes(this.store, event => this.emit(event), job, outcomes);
     }
     async applyTaskEffectOutcomes(job, task, outcomes) {
-        for (const outcome of outcomes.filter(item => item.status === 'failed')) {
-            const eventName = workflowEffectFailureEvent(outcome.effect);
-            try {
-                await transitionTaskEvent(task, eventName);
-                task.error = outcome.error ?? `${outcome.effect} failed`;
-                await this.store.saveTask(task);
-            }
-            catch {
-                // The effect failure remains observable even if this state has no feedback transition.
-            }
-            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'workflow.effect.failed', 'failed', `${outcome.effect} failed: ${outcome.error ?? 'unknown error'}`, 'orchestrator', { effect: outcome.effect, idempotencyKey: outcome.key, workflowEvent: eventName }, { agent: 'relay', component: 'agents-relay' }));
-        }
+        await applyTaskEffectOutcomes(this.store, event => this.emit(event), job, task, outcomes);
     }
     async applyEvent(event) {
         const sourceId = eventSourceId(event);
@@ -256,6 +235,28 @@ export class ReconcilerRuntimeBase {
     isCorrelatedWorkerEvent(task, event) {
         return task.executionId !== null && eventSourceId(event) === executionEventSource(event.job_id, task.id, task.executionId);
     }
+    finalizeReviewExecution(jobId, task, event, afterCommit = true) {
+        if (!task.executionId)
+            return true;
+        const sourceId = eventSourceId(event);
+        const expected = executionEventSource(jobId, task.id, task.executionId);
+        if ((task.adapter === 'codex' || task.adapter === 'chatgpt') && sourceId !== expected)
+            return false;
+        if (afterCommit)
+            claimTerminalExecution(expected);
+        const executionId = task.executionId;
+        if (afterCommit)
+            this.clearExecution(task.id, executionId);
+        task.leaseOwner = null;
+        task.leaseExpiresAt = null;
+        task.executionId = null;
+        task.updatedAt = new Date().toISOString();
+        if (afterCommit) {
+            this.terminalWaiters.get(task.id)?.resolve();
+            this.terminalWaiters.delete(task.id);
+        }
+        return true;
+    }
     async failLaunch(jobId, taskId, executionId, message, phase = 'launch') {
         const claim = executionId ?? `${jobId}:${taskId}`;
         if (this.launchFailureClaims.has(claim))
@@ -282,6 +283,11 @@ export class ReconcilerRuntimeBase {
         }
         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');
+        // failLaunch already committed the authoritative FAILED state. The emitted
+        // task.failed observation may be ignored as a duplicate, so explicitly wake
+        // graph reconciliation from the durable failure fact. This is required for
+        // automatic Troubleshooter recovery, including reviewer start-ack failures.
+        this.detach(this.eventCoordinator.accept({ jobId, reason: `worker-${phase}-failure` }), jobId, taskId, 'worker failure reconcile wake');
     }
     async runtimeSettled(jobId, taskId, executionId, result, error) {
         const live = this.live.get(taskId);
@@ -291,7 +297,15 @@ export class ReconcilerRuntimeBase {
         }
         const job = await this.store.load(jobId);
         const task = job.tasks.find(item => item.id === taskId);
-        if (terminalExecutionClaimed(jobId, taskId, executionId) || !task || task.executionId !== executionId)
+        // Async transport settlement is an independent, non-authoritative observation.
+        // A worker terminal event may already have claimed the Task; do not suppress
+        // transport-exit evidence merely because business completion won the race.
+        if (!task)
+            return;
+        const correlated = task.executionId === executionId || task.executionHistory?.some(item => item.id === executionId);
+        if (!correlated)
+            return;
+        if (task.adapter !== 'chatgpt' && (task.executionId !== executionId || terminalExecutionClaimed(jobId, taskId, executionId)))
             return;
         if (task.adapter !== 'chatgpt' && task.executionId === executionId && live?.executionId === executionId)
             rearmTerminalEventDeadline(this.terminalTimers, taskId, task.timeoutMs - (Date.now() - live.launchBarrier), this.options.postExitTerminalGraceMs ?? 15_000, () => this.detach(this.timeoutTask(jobId, taskId, executionId), jobId, taskId, 'post-exit terminal event timeout'));
@@ -307,7 +321,7 @@ export class ReconcilerRuntimeBase {
         const exit = live?.executionId === executionId && live.processSettled ? live.execution.processExit : undefined;
         const rawError = live?.executionId === executionId && live.processSettled ? (live.processError || exit?.stderr || '').trim() : '';
         const failedExit = Boolean(exit && (exit.exitCode !== 0 || exit.signal));
-        const failureReason = failedExit ? (/rate.limit.exceeded|usage limit reached/i.test(rawError) ? 'rate_limit_exceeded' : 'worker_process_failed') : 'terminal_event_timeout';
+        const failureReason = failedExit ? classifyWorkerRejection(rawError) : 'terminal_event_timeout';
         const failureMessage = failedExit ? (rawError || `Worker exited with code ${exit?.exitCode ?? 'null'}${exit?.signal ? `, signal ${exit.signal}` : ''}`) : `Task ${taskId} timed out waiting for the mandatory terminal worker event`;
         const transition = await this.taskTransitions.apply(jobId, taskId, 'watchdog.failed', {
             eligible: (_job, task) => task.executionId === executionId,
@@ -323,21 +337,38 @@ export class ReconcilerRuntimeBase {
             this.clearExecution(taskId, executionId);
             return;
         }
-        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? failureMessage, 'user', { reason: failureReason, exitCode: exit?.exitCode ?? null, signal: exit?.signal ?? null, timeoutMs: transition.task.timeoutMs, workflowEvent: 'watchdog.failed', executionId }, { agent: 'relay', component: 'agents-relay', watchdog: true });
-        await this.emit(event);
-        // Provider quota failures are recoverable. Drop the stale selection so the
-        // next launch runs the normal worker/model router with fresh usage data.
-        if (failureReason === 'rate_limit_exceeded' && transition.task.attempt < transition.task.maxAttempts) {
+        let reroutedTask = null;
+        // Provider quota failures are recoverable. Commit the retry + route exclusion
+        // before publishing task.failed so event-driven reconciliation can never see
+        // an intermediate FAILED state and spawn a Troubleshooter for quota exhaustion.
+        if (reroutableWorkerRejections.has(failureReason) && transition.task.attempt < transition.task.maxAttempts) {
             const current = (await this.store.load(jobId)).tasks.find(task => task.id === taskId);
             if (current?.state === 'FAILED' && current.failureReason === failureReason && current.attempt === transition.task.attempt) {
+                const failedRoute = current.routing;
                 await applyTaskRetryAction(current);
+                if (failedRoute) {
+                    const duplicate = current.routingExclusions?.some(item => item.provider === failedRoute.provider && item.model === failedRoute.model && item.profile === failedRoute.profile);
+                    if (!duplicate)
+                        current.routingExclusions = [...(current.routingExclusions ?? []), {
+                                provider: failedRoute.provider,
+                                model: failedRoute.model,
+                                ...(failedRoute.profile ? { profile: failedRoute.profile } : {}),
+                                reason: 'rate_limit_exceeded',
+                                at: new Date().toISOString(),
+                            }];
+                }
                 current.routing = undefined;
                 current.workerSelection = undefined;
                 await this.store.saveTask(current);
-                await this.emit(eventFor(jobId, taskId, current.parentTaskId, 'task.rerouting', 'queued', 'Provider rate limit reached; retrying with fresh routing and usage data', 'orchestrator', { previousFailure: failureReason, attempt: current.attempt, maxAttempts: current.maxAttempts }));
-                await this.eventCoordinator.accept({ jobId, reason: 'rate-limit-reroute' });
+                reroutedTask = current;
             }
         }
+        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? failureMessage, 'user', { reason: failureReason, exitCode: exit?.exitCode ?? null, signal: exit?.signal ?? null, timeoutMs: transition.task.timeoutMs, workflowEvent: 'watchdog.failed', executionId }, { agent: 'relay', component: 'agents-relay', watchdog: true });
+        await this.emit(event);
+        if (reroutedTask) {
+            await this.emit(eventFor(jobId, taskId, reroutedTask.parentTaskId, 'task.rerouting', 'queued', `Worker rejection ${failureReason}; retrying with fresh routing and usage data`, 'orchestrator', { previousFailure: failureReason, attempt: reroutedTask.attempt, maxAttempts: reroutedTask.maxAttempts }));
+            await this.eventCoordinator.accept({ jobId, reason: 'worker-rejection-reroute' });
+        }
     }
     async applyTerminalEvent(event, trustedInternal = false) {
         const liveAtTerminal = this.live.get(event.task_id);
@@ -346,6 +377,10 @@ export class ReconcilerRuntimeBase {
             eligible: (_job, task) => {
                 if (!['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
                     return false;
+                // Reviewer business terminal state is owned by review.approved / review.changes_required / review.blocked.
+                // A generic task.completed may arrive before the review decision and must not consume the execution generation.
+                if (task.agentName === 'reviewer' && event.type === 'task.completed')
+                    return false;
                 const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
                 if (!trustedInternal && modelBacked && !this.isCorrelatedWorkerEvent(task, event)) {
                     const eventExecutionId = executionIdFromSource(eventSourceId(event), _job.id, task.id);

package/dist/reconciler.js

@@ -1,12 +1,15 @@
+import { cancelActiveTasks } from './reconciler-cancellation.js';
+import { authorizedInjection } from './e2e-injection.js';
 import { implementationComplete } from './runtime-status.js';
 import { bindPlannedReviewHead } from './planned-review-head.js';
 import { randomUUID } from 'node:crypto';
 import { storySizeTimeoutMs, chatGptStartAckTimeoutMs } from './types.js';
 import { dependencyReady, schedule, transitionTaskEvent } from './scheduler.js';
-import { applyTaskCancelAction } from './task-actions.js';
+import { applyTaskRetryAction } from './task-actions.js';
 import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
 import { createPlanRound, materializePlannerChild, pendingPlan } from './planner.js';
+import { retryPendingPlannerUnblocks } from './planner-runtime.js';
 import { dispatchPlannerOrchestration, plannerOrchestrationFacts } from './workflow/planner-orchestration-v2.js';
 import { resolveExecutionContext } from './execution-context.js';
 import { ReconcilerReviewBase } from './reconciler-review.js';
@@ -15,7 +18,7 @@ import { executeManualPlan } from './manual-plan.js';
 import { executionEventSource, withExecutionBoundary } from './reconciler-runtime.js';
 export { executionEventSource } from './reconciler-runtime.js';
 import { CallbackWorkflowEffectHandler } from './workflow/effects.js';
-import { pendingTroubleshooterTasks } from './troubleshooter.js';
+import { exhaustedTroubleshooterRecoveries, pendingTroubleshooterTasks } from './troubleshooter.js';
 import { taskUsesCanonicalProjectRun } from './workspace.js';
 import { cleanupMergedJobWorktree } from './job-worktree-cleanup.js';
 import { jobHasActiveExecution } from './job-execution-slot.js';
@@ -98,10 +101,49 @@ export class Reconciler extends ReconcilerReviewBase {
                 await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.orchestrator_rescued', 'queued', `Stale orchestrator task ${task.id} converted to ChatGPT execution`, 'orchestrator', { ageMs: rescue.ageMs, adapter: 'chatgpt' }, { agent: 'relay', component: 'agents-relay' }));
             }
             await this.recoverPlannerChildren(job);
+            await retryPendingPlannerUnblocks({
+                store: this.store,
+                options: this.options,
+                live: this.plannerLive,
+                plannerContext: (currentJob, currentPlan) => this.plannerContext(currentJob, currentPlan),
+                emit: event => this.emit(event),
+                detach: (promise, currentJobId, planId, context) => this.detach(promise, currentJobId, planId, context),
+                reconcile: currentJobId => this.reconcile(currentJobId),
+            }, jobId);
             for (const recovery of pendingTroubleshooterTasks(await this.store.load(jobId))) {
                 await this.store.appendTask(recovery);
                 await this.emit(eventFor(job.id, recovery.id, null, "troubleshooter.created", "queued", "Troubleshooter task " + recovery.id + " created for failed/blocked work", "orchestrator", { agentName: "troubleshooter" }));
             }
+            {
+                const recoveryJob = await this.store.load(jobId);
+                // A failed recovery worker is itself recoverable: retry the SAME Task
+                // within its budget. No recursive Troubleshooter is generated.
+                for (const recovery of recoveryJob.tasks) {
+                    if (recovery.agentName !== 'troubleshooter' || recovery.state !== 'FAILED' || recovery.attempt >= recovery.maxAttempts)
+                        continue;
+                    const original = recoveryJob.tasks.find(task => task.id === recovery.parentTaskId);
+                    if (!original || !['FAILED', 'BLOCKED'].includes(original.state))
+                        continue;
+                    await applyTaskRetryAction(recovery);
+                    recovery.routing = undefined;
+                    recovery.workerSelection = undefined;
+                    await this.store.saveTask(recovery);
+                    await this.emit(eventFor(job.id, recovery.id, original.id, 'troubleshooter.retry_queued', 'queued', `Retrying failed Troubleshooter ${recovery.id} (attempt ${recovery.attempt + 1}/${recovery.maxAttempts})`, 'orchestrator', { originalTaskId: original.id, attempt: recovery.attempt + 1, maxAttempts: recovery.maxAttempts }));
+                }
+                const exhaustedJob = await this.store.load(jobId);
+                for (const exhausted of exhaustedTroubleshooterRecoveries(exhaustedJob)) {
+                    const at = new Date().toISOString();
+                    exhaustedJob.recoveryFailures = [...(exhaustedJob.recoveryFailures ?? []), {
+                            taskId: exhausted.original.id,
+                            recoveryTaskId: exhausted.recovery.id,
+                            reason: exhausted.reason,
+                            at,
+                        }];
+                    exhaustedJob.updatedAt = at;
+                    await this.store.saveJob(exhaustedJob);
+                    await this.emit(eventFor(job.id, exhausted.recovery.id, exhausted.original.id, 'recovery.exhausted', 'failed', `Recovery exhausted for ${exhausted.original.id}: ${exhausted.reason}`, 'user', { originalTaskId: exhausted.original.id, recoveryTaskId: exhausted.recovery.id, reason: exhausted.reason }, { agent: 'relay', component: 'agents-relay' }));
+                }
+            }
             for (const task of job.tasks)
                 if (task.state === 'CANCELLED') {
                     this.cancelExecutionGeneration(job.id, task.id, task.executionId ?? task.executionHistory?.at(-1)?.id);
@@ -133,7 +175,7 @@ export class Reconciler extends ReconcilerReviewBase {
             await this.ensureFinalReview(finalState, headSha);
             await this.dispatchExecutableTasks(jobId);
             finalState = await this.store.load(jobId);
-            if (await reconcileLocalGitCompletion(this.store, finalState, headSha, true, this.options.projectPathForJob))
+            if (await reconcileLocalGitCompletion(this.store, finalState, headSha, this.options.noGitHub === true, this.options.projectPathForJob))
                 return this.store.load(jobId);
             await dispatchJobReconcile(finalState, { jobActive: finalState.state === 'ACTIVE', implementationComplete: implementationComplete(finalState), headAvailable: Boolean(headSha), deliveryReady: finalState.localMerge?.status === 'succeeded' }, async (actionId) => {
                 const outcomes = await this.workflowEffects.execute([actionId], { jobId: finalState.id, transitionKey: `reconcile:${headSha ?? 'no-head'}`, data: { headSha } });
@@ -172,29 +214,11 @@ export class Reconciler extends ReconcilerReviewBase {
         }
     }
     async cancelActiveTasks(jobId, reason) {
-        const job = await this.store.load(jobId);
-        for (const plan of (job.plans ?? []).filter(item => item.status === 'PLANNING')) {
-            const live = this.plannerLive.get(plan.id);
-            if (live) {
-                clearTimeout(live.timer);
-                live.controller.abort();
-                this.plannerLive.delete(plan.id);
-            }
-            plan.status = 'FAILED';
-            plan.error = reason;
-            plan.assessment = `Planning failed: ${reason}`;
-            plan.leaseOwner = null;
-            plan.leaseExpiresAt = null;
-            plan.executionId = null;
-            plan.updatedAt = new Date().toISOString();
-            await this.store.savePlan(plan);
-        }
-        for (const task of job.tasks.filter(item => item.kind !== 'planner' && !['SUCCEEDED', 'FAILED', 'UNBLOCKED', 'CANCELLED'].includes(item.state))) {
-            this.cancelExecutionGeneration(job.id, task.id, task.executionId ?? task.executionHistory?.at(-1)?.id);
-            this.plannerLive.get(task.id)?.controller.abort();
-            await applyTaskCancelAction(task, reason);
-            await this.store.saveTask(task);
-        }
+        return cancelActiveTasks(this.store, jobId, reason, taskId => { const live = this.plannerLive.get(taskId); if (live) {
+            clearTimeout(live.timer);
+            live.controller.abort();
+            this.plannerLive.delete(taskId);
+        } }, (job, taskId, executionId) => { this.cancelExecutionGeneration(job, taskId, executionId); });
     }
     executionRecoveryPorts(job) {
         return {
@@ -339,6 +363,31 @@ export class Reconciler extends ReconcilerReviewBase {
                     attempt: freshTask.attempt,
                     startedAt: new Date(startedAt).toISOString(),
                 }].slice(-8);
+            if (this.store.mutateJob) {
+                let claimed;
+                await this.store.mutateJob(job.id, current => {
+                    const durable = current.tasks.find(item => item.id === freshTask.id);
+                    if (!durable || durable.state !== 'QUEUED' || durable.executionId !== null
+                        || !dependencyReady(durable, new Map(current.tasks.map(item => [item.id, item]))))
+                        return current;
+                    // Routing is a pre-claim fact; copy only that fact into the fresh
+                    // authoritative snapshot, then claim the generation atomically.
+                    if (freshTask.routing)
+                        durable.routing = structuredClone(freshTask.routing);
+                    if (freshTask.workerSelection)
+                        durable.workerSelection = structuredClone(freshTask.workerSelection);
+                    durable.attempt += 1;
+                    durable.leaseOwner = this.options.owner;
+                    durable.leaseExpiresAt = new Date(startedAt + leaseMs).toISOString();
+                    durable.executionId = randomUUID();
+                    durable.executionHistory = [...(durable.executionHistory ?? []), {
+                            id: durable.executionId, attempt: durable.attempt, startedAt: new Date(startedAt).toISOString(),
+                        }].slice(-8);
+                    claimed = structuredClone(durable);
+                    return current;
+                });
+                return claimed;
+            }
             await this.store.saveTask(freshTask);
             return freshTask;
         }) ?? null;
@@ -380,7 +429,24 @@ export class Reconciler extends ReconcilerReviewBase {
         const startAckSetup = task.adapter === 'chatgpt' ? await this.startAck(job.id, task.id, sourceId, Date.now(), this.options.startAckTimeoutMs ?? chatGptStartAckTimeoutMs(task.timeoutMs)) : null;
         const closePolicy = task.chatgptTabClosePolicy ?? this.options.chatgptTabClosePolicy ?? adapter.tabClosePolicy ?? 'after-start';
         const terminalWait = task.adapter === 'chatgpt' && closePolicy === 'after-terminal' ? this.terminalWait(task.id, durableExecutionId, startedAt - 1) : null;
+        // Consume E2E injection before execution: a retry will not repeat it.
+        // Production repositories ignore the option entirely.
+        const declaration = authorizedInjection(job.repository, task.testInjection);
+        const testInjection = declaration && ((task.adapter === 'codex' && declaration.method === 'worker.codex.launch') || (task.adapter === 'chatgpt' && declaration.method === 'browserWorkspace.command')) ? declaration : undefined;
+        if (testInjection) {
+            const durable = (await this.store.load(job.id)).tasks.find(item => item.id === task.id);
+            if (!durable || durable.executionId !== durableExecutionId)
+                return;
+            delete durable.testInjection;
+            durable.updatedAt = new Date(Math.max(Date.now(), Date.parse(durable.updatedAt) + 1)).toISOString();
+            await this.store.saveTask(durable);
+            const consumed = (await this.store.load(job.id)).tasks.find(item => item.id === task.id);
+            if (!consumed || consumed.executionId !== durableExecutionId || consumed.testInjection)
+                throw new Error(`E2E injection consumption was not durably committed for ${task.id}`);
+            delete task.testInjection;
+        }
         const launchContext = {
+            ...(testInjection ? { testInjection } : {}),
             ...(startAckSetup ? { waitForWorkerStart: startAckSetup.ack } : {}),
             ...(terminalWait ? { waitForTerminal: terminalWait.promise } : {}),
             executionContext,

package/dist/relayd-control.js

@@ -0,0 +1,184 @@
+export function createWorkspaceControl(deps) {
+    const { client, trusted, noGitHub, repositories, refreshAll, requireLocalJobBinding, makeReconciler, concurrency, pool, bus, isEffectivelyBlocked, unblockAutonomousTasks, unblockTask, publishTaskUnblocked, dispatchTaskAction, registerBlockerDependency, discoverAgents, ensureManagedGitHubJob } = deps;
+    const workspaceControl = async (body) => {
+        const command = typeof body.command === 'string' ? body.command : '';
+        const jobId = typeof body.jobId === 'string' ? body.jobId : '';
+        if (!command)
+            throw new Error('control command is required');
+        if (command === 'job.create') {
+            const repository = typeof body.repository === 'string' ? body.repository : '';
+            const options = (body.options && typeof body.options === 'object' ? body.options : {});
+            if (!repository || typeof options.id !== 'string' || !options.id)
+                throw new Error('job.create requires repository and id');
+            const result = await ensureManagedGitHubJob(client, repository, trusted, {
+                id: options.id,
+                title: typeof options.title === 'string' ? options.title : undefined,
+                objective: typeof options.objective === 'string' ? options.objective : undefined,
+                projectPath: typeof options.projectPath === 'string' ? options.projectPath : undefined,
+                priority: options.priority,
+                executionMode: options.executionMode,
+                schedule: options.schedule,
+                tag: options.tag,
+                reviewEnabled: typeof options.reviewEnabled === 'boolean' ? options.reviewEnabled : undefined,
+                continuation: options.continuation,
+                prNumber: typeof options.prNumber === 'number' ? options.prNumber : undefined,
+                head: typeof options.head === 'string' ? options.head : undefined,
+                base: typeof options.base === 'string' ? options.base : undefined,
+                body: typeof options.body === 'string' ? options.body : undefined,
+                reviewerThreadId: typeof options.reviewerThreadId === 'string' ? options.reviewerThreadId : undefined,
+                creatorThreadId: typeof options.creatorThreadId === 'string' ? options.creatorThreadId : undefined,
+                noGitHub,
+                localMergeSource: typeof options.localMergeSource === 'string' ? options.localMergeSource : undefined,
+                localMergeTarget: typeof options.localMergeTarget === 'string' ? options.localMergeTarget : undefined,
+            });
+            if (!repositories.includes(repository))
+                repositories.push(repository);
+            await refreshAll();
+            if (body.initialPlan === true) {
+                const binding = await requireLocalJobBinding(result.job.id);
+                const reconciler = makeReconciler(binding.store, concurrency);
+                try {
+                    const planned = await reconciler.planJob(result.job.id);
+                    await pool.reconcileLocalJob(result.job.id, 'control.job.create.initial-plan');
+                    return { repository, pr: result.pr.number, job: result.job.id, executionMode: result.job.executionMode, state: result.job.state, initialPlan: planned.round.id };
+                }
+                finally {
+                    await reconciler.close();
+                }
+            }
+            return { repository, pr: result.pr.number, job: result.job.id, executionMode: result.job.executionMode, state: result.job.state };
+        }
+        if (!jobId)
+            throw new Error(command + ' requires jobId');
+        const binding = await requireLocalJobBinding(jobId);
+        const store = binding.store;
+        const job = await store.load(jobId);
+        if (command === 'job.update') {
+            const patch = (body.patch && typeof body.patch === 'object' ? body.patch : {});
+            const mutable = ['title', 'objective', 'projectPath', 'priority', 'executionMode', 'schedule', 'tag', 'autoMerge', 'reviewEnabled', 'reviewerThreadId', 'creatorThreadId', 'continuation', 'localMerge'];
+            for (const key of mutable)
+                if (Object.prototype.hasOwnProperty.call(patch, key))
+                    job[key] = patch[key];
+            job.updatedAt = new Date().toISOString();
+            await store.saveJob(job);
+            await refreshAll();
+            return await store.load(jobId);
+        }
+        if (command === 'job.plan') {
+            const reconciler = makeReconciler(store, concurrency);
+            try {
+                const planned = await reconciler.planJob(jobId, typeof body.guidance === 'string' && body.guidance.trim() ? body.guidance : undefined);
+                await pool.reconcileLocalJob(jobId, 'control.job.plan');
+                return planned.round;
+            }
+            finally {
+                await reconciler.close();
+            }
+        }
+        if (command === 'job.unblock') {
+            const reason = typeof body.reason === 'string' ? body.reason : '';
+            if (!reason.trim())
+                throw new Error('job unblock requires reason');
+            const blocked = job.tasks.filter(isEffectivelyBlocked);
+            if (!blocked.length)
+                throw new Error(`Job ${job.id} has no effective BLOCKED work task`);
+            if (job.executionMode === 'autonomous')
+                await unblockAutonomousTasks({ store, job, tasks: blocked, trigger: { source: 'cli', reason } });
+            else
+                for (const task of blocked)
+                    await unblockTask({ store, job, task, trigger: { source: 'cli', reason } });
+            const refreshed = await store.load(jobId);
+            for (const task of blocked)
+                await publishTaskUnblocked(bus, refreshed, task.id, reason);
+            await pool.reconcileLocalJob(jobId, 'control.job.unblock');
+            return await store.load(jobId);
+        }
+        if (command === 'task.recover') {
+            const taskId = typeof body.taskId === 'string' ? body.taskId : '';
+            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 pool.reconcileLocalJob(jobId, 'control.task.recover');
+            return await store.load(jobId);
+        }
+        if (command === 'task.unblock') {
+            const taskId = typeof body.taskId === 'string' ? body.taskId : '';
+            const reason = typeof body.reason === 'string' ? body.reason : '';
+            const task = job.tasks.find((item) => item.id === taskId);
+            if (!task)
+                throw new Error(`Task ${taskId} not found`);
+            await unblockTask({ store, job, task, trigger: { source: 'cli', reason } });
+            const refreshed = await store.load(jobId);
+            await publishTaskUnblocked(bus, refreshed, taskId, reason);
+            await pool.reconcileLocalJob(jobId, 'control.task.unblock');
+            return await store.load(jobId);
+        }
+        if (command === 'review.request') {
+            if (job.state === 'CANCELLED' || job.state === 'COMPLETED')
+                throw new Error('Cannot request review for terminal Job');
+            if (!job.reviewEnabled)
+                throw new Error('Review disabled for this Job');
+            if (typeof body.threadId === 'string') {
+                job.reviewerThreadId = body.threadId;
+                job.updatedAt = new Date().toISOString();
+                await store.saveJob(job);
+            }
+            await pool.reconcileLocalJob(jobId, 'control.review.request');
+            return await store.load(jobId);
+        }
+        if (command === 'blocker.add') {
+            const dependentJobId = typeof body.dependentJobId === 'string' ? body.dependentJobId : '';
+            const dependentTaskId = typeof body.dependentTaskId === 'string' ? body.dependentTaskId : '';
+            const dependent = await requireLocalJobBinding(dependentJobId);
+            const relation = await registerBlockerDependency({ blockerStore: store, blockerJobId: jobId, dependentStore: dependent.store, dependentJobId, dependentTaskId, resolutionMode: body.resolutionMode === 'verified' ? 'verified' : 'merge' });
+            await refreshAll();
+            return relation;
+        }
+        if (command === 'blocker.resolve') {
+            if (!store.resolveBlockerDependents)
+                throw new Error('Blocker resolution unavailable');
+            const summary = await store.resolveBlockerDependents(jobId, body.resolution === 'merge' ? 'merge' : 'verified');
+            for (const target of summary.unblocked)
+                await pool.reconcileLocalJob(target.jobId, 'control.blocker.resolve');
+            await refreshAll();
+            return summary;
+        }
+        if (command === 'projection.conflicts')
+            return await binding.relay.listProjectionConflicts();
+        if (command === 'job.reconcile') {
+            await pool.reconcileLocalJob(jobId, 'control.job.reconcile');
+            return await store.load(jobId);
+        }
+        if (command === 'agent.discover') {
+            return discoverAgents(await store.listAgents(), (body.requirements && typeof body.requirements === 'object' ? body.requirements : {}));
+        }
+        if (command === 'projection.resolve') {
+            const id = Number(body.projectionId);
+            const action = body.action === 'discard_local' ? 'discard_local' : 'requeue';
+            if (!Number.isInteger(id) || id <= 0)
+                throw new Error('projection resolve requires projectionId');
+            const resolved = await binding.relay.resolveProjectionConflict(id, { action, ...(typeof body.note === 'string' && body.note ? { note: body.note } : {}) });
+            if (!resolved)
+                throw new Error(`Projection ${id} is not in a resolvable conflict state`);
+            return { resolved: id, action };
+        }
+        if (command === 'record') {
+            const task = body.task;
+            if (!task || task.jobId !== jobId)
+                throw new Error('record requires a task for this Job');
+            await store.appendTask(task);
+            await pool.reconcileLocalJob(jobId, 'control.record');
+            return await store.load(jobId);
+        }
+        if (command === 'agent.register') {
+            const agent = body.agent;
+            if (!agent)
+                throw new Error('agent.register requires agent');
+            await store.saveAgent(agent);
+            return agent;
+        }
+        throw new Error('Unsupported control command ' + command);
+    };
+    return workspaceControl;
+}

package/dist/relayd-dashboard-actions.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+export function createDashboardActions(deps) {
+    const { cachedOverviews, requireLocalJobBinding, pool, dashboardJobAction, makeReconciler, concurrency, dashboardJobSetState, refreshAll, applyJobActivateAction, applyOrchestratorStartAction, applyOrchestratorCompleteAction, publishOrchestratorTaskStarted, publishOrchestratorTaskCompletion, bus, dashboardTaskAction, dashboardTaskSetState } = deps;
+    const dashboardOverview = (jobId, target) => cachedOverviews.find((item) => item.job.id === jobId
+        && (!target?.repository || item.job.repository === target.repository)
+        && (!target?.prNumber || (item.job.externalPrNumber ?? item.job.prNumber) === target.prNumber));
+    const workspaceJobAction = (action) => async (jobId) => {
+        const overview = cachedOverviews.find((item) => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        if (action === 'reconcile') {
+            await pool.reconcileLocalJob(jobId, 'control.job.reconcile');
+            return await store.load(jobId);
+        }
+        return await dashboardJobAction(store, makeReconciler(store, concurrency), action)(jobId);
+    };
+    const workspaceJobSetState = async (jobId, state, target) => {
+        const overview = dashboardOverview(jobId, target);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        const result = await dashboardJobSetState(store)(jobId, state);
+        await refreshAll();
+        return result;
+    };
+    const workspaceTaskCreate = async (jobId, task) => {
+        const overview = cachedOverviews.find((item) => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        if (task.jobId !== jobId)
+            throw new Error(`Task ${task.id} belongs to ${task.jobId}, not ${jobId}`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        const job = await store.load(jobId);
+        if (['COMPLETED', 'CANCELLED'].includes(job.state))
+            throw new Error(`Cannot create task on terminal job ${job.id} (${job.state})`);
+        if (store.mutateJob) {
+            await store.mutateJob(jobId, (current) => {
+                if (['COMPLETED', 'CANCELLED'].includes(current.state))
+                    throw new Error(`Cannot create task on terminal job ${current.id}`);
+                if (current.tasks.some((item) => item.id === task.id))
+                    throw new Error(`Task ${task.id} already exists`);
+                current.tasks.push(structuredClone(task));
+                if (current.state === 'DRAFT')
+                    applyJobActivateAction(current);
+                current.updatedAt = new Date().toISOString();
+                return current;
+            });
+        }
+        else {
+            await store.appendTask(task);
+            const refreshed = await store.load(jobId);
+            if (refreshed.state === 'DRAFT') {
+                await applyJobActivateAction(refreshed);
+                await store.saveJob(refreshed);
+            }
+        }
+        await pool.reconcileLocalJob(jobId, 'control.task.create');
+        return await store.load(jobId);
+    };
+    const workspaceTaskStart = async (jobId, taskId) => {
+        const overview = cachedOverviews.find((item) => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        const job = await store.load(jobId);
+        const task = job.tasks.find((item) => item.id === taskId);
+        if (!task)
+            throw new Error(`Task ${taskId} not found`);
+        await applyOrchestratorStartAction(task);
+        await store.saveTask(task);
+        await publishOrchestratorTaskStarted(bus, job, task);
+        await pool.reconcileLocalJob(jobId, 'control.task.start');
+        return await store.load(jobId);
+    };
+    const workspaceTaskComplete = async (jobId, taskId, summary) => {
+        const overview = cachedOverviews.find((item) => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        const job = await store.load(jobId);
+        const task = job.tasks.find((item) => item.id === taskId);
+        if (!task)
+            throw new Error(`Task ${taskId} not found`);
+        await applyOrchestratorCompleteAction(task, summary);
+        await store.saveTask(task);
+        await publishOrchestratorTaskCompletion(bus, job, task, summary);
+        await pool.reconcileLocalJob(jobId, 'control.task.complete');
+        return await store.load(jobId);
+    };
+    const workspaceTaskAction = (action) => async (jobId, taskId) => {
+        const overview = cachedOverviews.find((item) => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        return await dashboardTaskAction(store, makeReconciler(store, concurrency), action)(jobId, taskId);
+    };
+    const workspaceTaskSetState = async (jobId, taskId, state, target) => {
+        const overview = dashboardOverview(jobId, target);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        const result = await dashboardTaskSetState(store)(jobId, taskId, state);
+        await refreshAll();
+        return result;
+    };
+    return { dashboardOverview, workspaceJobAction, workspaceJobSetState, workspaceTaskCreate, workspaceTaskStart, workspaceTaskComplete, workspaceTaskAction, workspaceTaskSetState };
+}