agents-relay 2.0.80 → 2.0.82

package/dist/managed-worker-input.js

@@ -4,9 +4,8 @@ import { createReviewChairExecutionPlan } from './review-chair.js';
 import { taskTagWorkerPrompt } from './task-tag.js';
 import { executionEventSource } from './reconciler-runtime.js';
 export async function managedWorkerInput(job, task, context) {
-    const isLocalJob = job.prNumber === 0;
-    const externalPrNumber = job.externalPrNumber && job.externalPrNumber > 0 ? job.externalPrNumber : (job.prNumber > 0 ? job.prNumber : 0);
-    const projectedReview = isLocalJob && task.agentName === 'reviewer' && externalPrNumber > 0;
+    const isLocalJob = Boolean(job.localMerge?.sourceRef);
+    const projectedReview = isLocalJob && task.agentName === 'reviewer' && job.prNumber > 0;
     if (!['codex', 'chatgpt'].includes(task.adapter) || !job.repository)
         return task.input;
     const selectedAgent = task.agentName && context ? await agentContractPrompt(context, task.agentName) : '';
@@ -19,7 +18,7 @@ export async function managedWorkerInput(job, task, context) {
     if (!task.executionId)
         throw new Error(`Task ${task.id} requires an executionId before worker input is built`);
     const sourceId = executionEventSource(job.id, task.id, task.executionId);
-    const prUrl = externalPrNumber > 0 ? `https://github.com/${job.repository}/pull/${externalPrNumber}` : null;
+    const prUrl = job.prNumber > 0 ? `https://github.com/${job.repository}/pull/${job.prNumber}` : null;
     const taskUrl = task.taskUrl ?? (isLocalJob ? `local:${job.id}/task/${task.id}` : `${prUrl}#issuecomment-${task.id}`);
     const output = task.output.kind === 'file'
         ? `file\nPath: ${task.output.path}`

package/dist/planner.js

@@ -16,7 +16,7 @@ export function semanticTaskTree(tasks) {
     const ids = new Set(work.map(task => task.id));
     return {
         roots: work.filter(task => !task.parentTaskId || !ids.has(task.parentTaskId)).map(task => task.id),
-        tasks: work.map(task => ({ id: task.id, parent_task_id: task.parentTaskId, state: task.state, dependencies: [...task.dependencies], planning_decision_id: task.planningDecisionId, planning_round: task.planningRound, review: task.review })),
+        tasks: work.map(task => ({ id: task.id, title: task.title, parent_task_id: task.parentTaskId, state: task.state, dependencies: [...task.dependencies], planning_decision_id: task.planningDecisionId, planning_round: task.planningRound, review: task.review })),
     };
 }
 function plannerTrigger(job, manual = false) {
@@ -113,14 +113,14 @@ export function materializePlannerChild(job, planner, spec, executionContext) {
         validateResolutionProposal(job, target, resolution);
     }
     const reviewerThread = spec.agentName === 'reviewer' ? prepareReviewerThreadDelivery(job, { id: spec.id, agentName: spec.agentName, reviewHeadSha }) : undefined;
-    return createTaskEntity(job, { 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, review: spec.review, parentTaskId: spec.parentTaskId ?? null, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: reviewerThread ? chatgptThreadRequirements(spec.workerRequirements) : spec.workerRequirements, testInjection: spec.testInjection, adapter: reviewerThread ? 'chatgpt' : 'codex', chatgptThreadDelivery: reviewerThread, input: spec.input, output: spec.output, continuation: spec.continuation ?? null, continuationDeliveredAt: null, 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: decisionId, planningSource: source, planningRound: round, reviewHeadSha, resolution: resolution ? { ...resolution, state: 'proposed', owner: 'planner', updatedAt: now } : undefined });
+    return createTaskEntity(job, { jobId: job.id, id: spec.id, title: spec.title, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, agentGraph: spec.agentGraph, review: spec.review, parentTaskId: spec.parentTaskId ?? null, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: reviewerThread ? chatgptThreadRequirements(spec.workerRequirements) : spec.workerRequirements, testInjection: spec.testInjection, adapter: reviewerThread ? 'chatgpt' : 'codex', chatgptThreadDelivery: reviewerThread, input: spec.input, output: spec.output, continuation: spec.continuation ?? null, continuationDeliveredAt: null, 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: decisionId, planningSource: source, planningRound: round, reviewHeadSha, resolution: resolution ? { ...resolution, state: 'proposed', owner: 'planner', updatedAt: now } : undefined });
 }
 export function planningSpec(task) {
-    if (!task.output && task.adapter !== 'orchestrator')
+    if (!task.output)
         throw new Error(`Initial task ${task.id} requires an output contract`);
-    if (!['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
-        throw new Error(`Initial task ${task.id} requires a supported adapter`);
-    return { id: task.id, parentTaskId: task.parentTaskId, input: task.input, priority: task.priority, storySize: task.storySize, projectName: task.projectName, agentName: task.agentName, agentGraph: task.agentGraph, review: task.review, dependencies: task.dependencies, capabilities: task.capabilities, workerRequirements: task.workerRequirements, testInjection: task.testInjection, adapter: task.adapter, output: task.output ?? { kind: 'task_pr' }, routing: task.routing, continuation: task.continuation, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs, resolution: task.resolution ? { ...task.resolution, state: undefined, owner: undefined, updatedAt: undefined } : undefined };
+    if (!['codex', 'chatgpt'].includes(task.adapter))
+        throw new Error(`Initial task ${task.id} requires a supported worker adapter`);
+    return { id: task.id, title: task.title, parentTaskId: task.parentTaskId, input: task.input, priority: task.priority, storySize: task.storySize, projectName: task.projectName, agentName: task.agentName, agentGraph: task.agentGraph, review: task.review, dependencies: task.dependencies, capabilities: task.capabilities, workerRequirements: task.workerRequirements, testInjection: task.testInjection, adapter: task.adapter, output: task.output ?? { kind: 'task_pr' }, routing: task.routing, continuation: task.continuation, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs, resolution: task.resolution ? { ...task.resolution, state: undefined, owner: undefined, updatedAt: undefined } : undefined };
 }
 function record(value, field = 'result') {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -309,7 +309,7 @@ export function parsePlannerResult(value) {
         if (typeof timeoutMs !== 'number' || !Number.isFinite(timeoutMs) || timeoutMs < 0)
             throw new Error(`Planner next_tasks[${index}].timeoutMs is invalid`);
         return {
-            id, parentTaskId, input: task.input, priority, storySize,
+            id, title: optionalString(task.title, `next_tasks[${index}].title`), parentTaskId, input: task.input, priority, storySize,
             projectName: optionalString(task.projectName, 'projectName'), agentName: optionalString(task.agentName, 'agentName'), agentGraph, review,
             dependencies: stringArray(task.dependencies, 'dependencies'), capabilities: stringArray(task.capabilities, 'capabilities'), workerRequirements: requirements,
             testInjection: parseTestInjection(task.testInjection ?? task['--test-injection']) ?? optionalString(task.testInjection ?? task['--test-injection'], `next_tasks[${index}].--test-injection`),
@@ -331,7 +331,7 @@ export function validatePlannerProgress(job, result) {
     throw new Error('Planner returned in_progress with no executable tasks or unblocks while no live work remains; return satisfied when only Relay-owned review/merge/completion effects remain');
 }
 export function validatePlannerLifecycleOwnership(job, specs) {
-    if (job.prNumber !== 0 || !job.localMerge)
+    if (!job.localMerge?.sourceRef)
         return;
     for (const spec of specs) {
         // Restrict ownership detection to an individual imperative clause. A long
@@ -347,6 +347,11 @@ export function validatePlannerLifecycleOwnership(job, specs) {
             if (ownsLifecycle && [localMerge, jobCompletion, externalMerge].filter(Boolean).length >= 2) {
                 throw new Error(`Planner next task ${spec.id} attempts to own Graph lifecycle delivery; local merge, Job COMPLETED, and projected PR merge are Relay-owned effects and must not be worker Tasks`);
             }
+            const releaseEffect = /\b(?:publish|release|deploy)\b.{0,100}\b(?:package|npm|service|runtime|version)\b|\b(?:package|npm|service|runtime)\b.{0,100}\b(?:publish|release|deploy)\b/.test(clause);
+            const releaseImperative = /^\s*(?:publish|release|deploy)\b|\b(?:then|and)\s+(?:publish|release|deploy)\b/.test(clause);
+            if (releaseEffect && releaseImperative) {
+                throw new Error(`Planner next task ${spec.id} attempts to own Relay release delivery; package publication and service/runtime deployment are Relay-owned effects and must not be worker Tasks`);
+            }
         }
     }
 }
@@ -431,6 +436,7 @@ export function plannerInput(context) {
         visible_agents: visibleAgents ?? [],
         tasks: context.tasks.map(task => ({
             id: task.id,
+            title: task.title,
             kind: task.kind ?? 'work',
             parent_task_id: task.parentTaskId,
             state: task.state,

package/dist/pool.js

@@ -12,7 +12,9 @@ export function needsLifecycleReconciliation(job, now = Date.now()) {
     // DRAFT create-only Jobs stay dormant until a caller explicitly creates work.
     if (job.tasks.length === 0)
         return false;
-    if (job.tasks.some(task => (task.state === 'QUEUED' && task.executionId === null) || (task.state === 'DRAFT' && task.dependencies.length > 0)))
+    if (job.tasks.some(task => (task.state === 'QUEUED' && task.executionId === null)
+        || (task.state === 'RUNNING' && task.adapter === 'orchestrator' && task.executionId === null)
+        || (task.state === 'DRAFT' && task.dependencies.length > 0)))
         return true;
     return job.tasks.some(task => ['RUNNING', 'QUEUED'].includes(task.state) && task.executionId !== null && task.leaseExpiresAt !== null && new Date(task.leaseExpiresAt).getTime() <= now);
 }

package/dist/reconciler-review.js

@@ -122,7 +122,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         throw new Error('Too many final review rounds for ' + headSha);
     }
     externalReviewPrNumber(job) {
-        return job.externalPrNumber && job.externalPrNumber > 0 ? job.externalPrNumber : job.prNumber;
+        return job.prNumber;
     }
     async createFinalReviewTask(job, headSha) {
         const id = this.nextFinalReviewTaskId(job, headSha);
@@ -163,7 +163,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         // Local-first Jobs may expose a review-only GitHub PR. Once such a PR is
         // bound, its projected head must match the authoritative local head before
         // a reviewer is asked to review that immutable PR identity.
-        if (!job.externalPrNumber || job.externalPrNumber <= 0 || !this.store.pullRequestHead)
+        if (!job.localMerge?.sourceRef || job.prNumber <= 0 || !this.store.pullRequestHead)
             return true;
         try {
             const projected = await this.store.pullRequestHead();
@@ -325,7 +325,10 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             return { applied: false, reconcile: false, reason: event.type + '.stale' };
         // Planner-created reviewer tasks predate the final-review Job gate. Bind
         // their first trustworthy review event to PENDING before dispatching it.
-        const initialReviewOutcome = !job.review && task.planningDecisionId ? 'pending' : job.review?.outcome;
+        const freshAfterStale = job.review?.outcome === 'stale'
+            && job.review.headSha !== headSha && Boolean(task.planningDecisionId);
+        const initialReviewOutcome = (!job.review || freshAfterStale) && task.planningDecisionId
+            ? 'pending' : job.review?.outcome;
         const taskDecision = this.store.mutateJob
             ? dispatchTaskLifecycleSync(structuredClone(task), event.type)
             : tryTransitionTaskEvent(task, event.type);
@@ -395,7 +398,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
                 Object.assign(freshTask, candidate);
                 // Bind the first Planner review only after the generation fence has
                 // checked the unmodified outer snapshot and authoritative SQLite state.
-                if (!current.review && freshTask.planningDecisionId) {
+                if ((!current.review || (current.review.outcome === 'stale' && current.review.headSha !== headSha)) && freshTask.planningDecisionId) {
                     current.review = { outcome: 'pending', headSha, taskId: freshTask.id, evidence: null, updatedAt: reviewUpdatedAt };
                 }
                 freshTask.error = null;

package/dist/reconciler-runtime.js

@@ -1,3 +1,4 @@
+import { normalizeReviewerTerminalEvent } from './review-terminal-normalization.js';
 import { applyJobEffectOutcomes, applyTaskEffectOutcomes } from './workflow-effect-failures.js';
 import { classifyWorkerRejection, reroutableWorkerRejections } from './worker-rejection.js';
 import { applyTaskRetryAction } from './task-actions.js';
@@ -89,6 +90,12 @@ export class ReconcilerRuntimeBase {
             return activeOwner.applyEvent(event);
         if (event.type === 'task.started')
             return this.markWorkerStarted(event);
+        if (event.type === 'task.completed') {
+            const task = (await this.store.load(event.job_id)).tasks.find(item => item.id === event.task_id);
+            const normalized = task?.agentName === 'reviewer' ? normalizeReviewerTerminalEvent(event) : null;
+            if (normalized)
+                return this.applyReviewEvent(normalized);
+        }
         if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type)) {
             const result = await this.applyTerminalEvent(event);
             if (event.type !== 'task.failed' || event.source?.watchdog !== true || event.data?.workflowEvent !== 'watchdog.failed' || result.reconcile)

package/dist/reconciler.js

@@ -28,7 +28,7 @@ export { managedWorkerInput } from './managed-worker-input.js';
 import { recoverExpiredExecutions, recoverStartupOrphans as recoverStartupExecutionOrphans } from './execution-recovery.js';
 import { dispatchJobReconcile } from './workflow/job-reconcile-v2.js';
 import { reconcileLocalGitCompletion } from './local-merge-delivery.js';
-import { applyOrchestratorRescue } from './workflow/orchestrator-rescue.js';
+import { repairLegacyOrchestrators } from './legacy-orchestrator-repair.js';
 import { launchPlanExecution } from './planner-runtime.js';
 import { classifyFailure, errorMessage, observability, withObservabilityCorrelation } from './observability.js';
 const PRIORITY_RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
@@ -93,13 +93,7 @@ export class Reconciler extends ReconcilerReviewBase {
             if (job.state !== 'ACTIVE')
                 return job;
             await recoverExpiredExecutions(job, now, this.executionRecoveryPorts(job));
-            for (const task of (await this.store.load(jobId)).tasks) {
-                const rescue = applyOrchestratorRescue(task, now);
-                if (!rescue.rescued)
-                    continue;
-                await this.store.saveTask(task);
-                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 repairLegacyOrchestrators(jobId, now, { store: this.store, owner: this.options.owner, emit: event => this.emit(event) });
             await this.recoverPlannerChildren(job);
             await retryPendingPlannerUnblocks({
                 store: this.store,

package/dist/relay-store.js

@@ -4,6 +4,7 @@ import { mkdirSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import { recordPublicationInDatabase, loadPublicationFromDatabase, listPublicationEventsFromDatabase } from './publication-store.js';
 import { observability } from './observability.js';
+import { migrateLegacyJobPrNumbers, normalizeLegacyJobPrNumber } from './job-pr-number-migration.js';
 import { ProjectionOutbox, SCHEMA_VERSION, logicalOperationKey, } from './projection-outbox.js';
 function newerRecord(local, remote) {
     if (!local)
@@ -99,6 +100,7 @@ export class SQLiteRelayStore {
       ${ProjectionOutbox.createTableSql()}
       ${ProjectionOutbox.createIndexSql()}
     `);
+        migrateLegacyJobPrNumbers(this.db);
         const current = this.db.prepare("SELECT value FROM relay_meta WHERE key='schema_version'").get();
         const version = current?.value ? Number(current.value) : 0;
         if (version > SCHEMA_VERSION)
@@ -119,11 +121,11 @@ export class SQLiteRelayStore {
     }
     async loadJob(jobId) {
         const row = this.db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(jobId);
-        return row?.json ? JSON.parse(row.json) : null;
+        return row?.json ? normalizeLegacyJobPrNumber(JSON.parse(row.json)) : null;
     }
     async listJobs() {
         const rows = this.db.prepare('SELECT json FROM job_snapshot ORDER BY job_id').all();
-        return rows.map(row => JSON.parse(row.json));
+        return rows.map(row => normalizeLegacyJobPrNumber(JSON.parse(row.json)));
     }
     async saveJob(job) {
         this.writeJobSnapshot(job, new Date().toISOString());
@@ -135,7 +137,7 @@ export class SQLiteRelayStore {
             const row = this.db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(jobId);
             if (!row?.json)
                 throw new Error(`Local authoritative Job ${jobId} not found`);
-            const current = JSON.parse(row.json);
+            const current = normalizeLegacyJobPrNumber(JSON.parse(row.json));
             const before = JSON.stringify(current);
             const next = mutation(current);
             if (next.id !== jobId)
@@ -388,7 +390,7 @@ export async function discoverLocalRelayStoreSnapshots(directory) {
         try {
             db = new DatabaseSync(path, { readOnly: true });
             const rows = db.prepare('SELECT json FROM job_snapshot ORDER BY job_id').all();
-            const jobs = rows.map(row => JSON.parse(row.json));
+            const jobs = rows.map(row => normalizeLegacyJobPrNumber(JSON.parse(row.json)));
             const row = db.prepare('SELECT state,head_ref,head_sha,observed_at FROM pull_request_facts WHERE id=1').get();
             const facts = row ? {
                 state: row.state,

package/dist/relayd-control.js

@@ -1,4 +1,5 @@
 import { normalizeThreadId } from './reviewer-thread.js';
+import { supersedeCancelledTask } from './task-actions.js';
 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) => {
@@ -106,6 +107,15 @@ export function createWorkspaceControl(deps) {
             await pool.reconcileLocalJob(jobId, 'control.job.unblock');
             return await store.load(jobId);
         }
+        if (command === 'task.supersede') {
+            const taskId = typeof body.taskId === 'string' ? body.taskId : '';
+            const reason = typeof body.reason === 'string' ? body.reason : '';
+            if (!taskId || !reason.trim())
+                throw new Error('task supersede requires taskId and reason');
+            await supersedeCancelledTask(store, jobId, taskId, reason);
+            await pool.reconcileLocalJob(jobId, 'control.task.supersede');
+            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 : '';

package/dist/relayd-dashboard-actions.js

@@ -3,11 +3,11 @@ import { allocateEntityId, isGeneratedEntityId } from './job-task-id-sequence.js
 import { relayStoreDirectory } from './relay-store.js';
 import { dispatchJobLifecycleSync } from './workflow/lifecycle.js';
 export function createDashboardActions(deps) {
-    const { getOverviews, requireLocalJobBinding, pool, dashboardJobAction, makeReconciler, concurrency, dashboardJobSetState, refreshAll, applyJobActivateAction, applyOrchestratorStartAction, applyOrchestratorCompleteAction, publishOrchestratorTaskStarted, publishOrchestratorTaskCompletion, bus, dashboardTaskAction, dashboardTaskSetState, storeDirectory } = deps;
+    const { getOverviews, requireLocalJobBinding, pool, dashboardJobAction, makeReconciler, concurrency, dashboardJobSetState, refreshAll, applyJobActivateAction, bus, dashboardTaskAction, dashboardTaskSetState, storeDirectory } = deps;
     const currentOverviews = () => getOverviews();
     const dashboardOverview = (jobId, target) => currentOverviews().find((item) => item.job.id === jobId
         && (!target?.repository || item.job.repository === target.repository)
-        && (!target?.prNumber || (item.job.externalPrNumber ?? item.job.prNumber) === target.prNumber));
+        && (!target?.prNumber || (item.job.prNumber) === target.prNumber));
     const workspaceJobAction = (action) => async (jobId) => {
         const overview = currentOverviews().find((item) => item.job.id === jobId);
         if (!overview)
@@ -84,36 +84,6 @@ export function createDashboardActions(deps) {
             await pool.reconcileLocalJob(jobId, 'control.task.create');
         return { ...(await store.load(jobId)), createdTaskId: task.id };
     };
-    const workspaceTaskStart = async (jobId, taskId) => {
-        const overview = currentOverviews().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 = currentOverviews().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 = currentOverviews().find((item) => item.job.id === jobId);
         if (!overview)
@@ -130,5 +100,5 @@ export function createDashboardActions(deps) {
         await refreshAll();
         return result;
     };
-    return { dashboardOverview, workspaceJobAction, workspaceJobSetState, workspaceTaskCreate, workspaceTaskStart, workspaceTaskComplete, workspaceTaskAction, workspaceTaskSetState };
+    return { dashboardOverview, workspaceJobAction, workspaceJobSetState, workspaceTaskCreate, workspaceTaskAction, workspaceTaskSetState };
 }

package/dist/relayd.js

@@ -24,14 +24,13 @@ import { githubAuthContext } from './github-auth.js';
 import { DisabledGitHubClient, noGitHubMode } from './no-github.js';
 import { basename } from 'node:path';
 import { dashboardJobAction, isEntrypoint, runtimePlanner, runtimeReviewer, startService, SERVICE_DEFAULTS } from './cli.js';
-import { eventBusResolutionMessage, publishOrchestratorTaskStarted, publishOrchestratorTaskCompletion, publishTaskUnblocked, resolveEventBus } from './cli-support.js';
+import { eventBusResolutionMessage, publishTaskUnblocked, resolveEventBus } from './cli-support.js';
 import { eventFor } from './events.js';
 import { dispatchTaskAction } from './task-actions.js';
 import { isEffectivelyBlocked, unblockAutonomousTasks, unblockTask } from './unblock.js';
 import { registerBlockerDependency } from './blockers.js';
 import { ensureManagedGitHubJob } from './cli-job-create.js';
 import { applyJobActivateAction } from './job-actions.js';
-import { applyOrchestratorStartAction, applyOrchestratorCompleteAction } from './task-actions.js';
 import { managedTaskUpdateHandler } from './task-update.js';
 import { dashboardJobSetState, dashboardTaskAction, dashboardTaskSetState } from './dashboard-actions.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
@@ -155,7 +154,7 @@ export async function runDaemon(argv) {
     cachedOverviews = await inventoryFromLocal();
     const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { noGitHub, 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(), runtimeSummaryProvider: () => ({ chatgptRunning: summarizeRuntime(cachedOverviews.map(item => item.job)).workers.chatgpt }), decisionEngine: executionDecisionEngine(), decisionMode: decisionMode(), decisionAuditStore, eventBus: bus, reviewer: runtimeReviewer(argv), projectPathForJob: async (job) => {
             const canonical = repositoryPaths.get(job.repository) ?? await resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot);
-            if (job.prNumber !== 0 || job.schedule)
+            if (!job.localMerge?.sourceRef || job.schedule)
                 return resolveRepositoryProjectPath(canonical, job.projectPath);
             const sourceRef = await ensureLocalJobSourceBranch(canonical, job);
             if (!store.mutateJob)
@@ -243,15 +242,15 @@ export async function runDaemon(argv) {
                 // A completed local Job may never have had a display PR. Publish main
                 // regardless: GitHub availability cannot determine SQLite completion.
                 if (discovered.state === 'COMPLETED' && discovered.localMerge?.status === 'succeeded'
-                    && (discovered.externalPrNumber ?? discovered.prNumber) <= 0) {
+                    && discovered.prNumber <= 0) {
                     const published = projectAuthoritativeLocalMerge(canonical, discovered);
                     if (published.status === 'projected')
                         await bus?.publish(eventFor(discovered.id, 'projection', null, 'projection.delivered', 'succeeded', `GitHub main synchronization ${published.status}`, 'orchestrator', { operation: 'github.syncMain', deliveryStatus: published.status, mergedCommitSha: published.localMergedCommitSha }, { agent: 'relay', component: 'github-projection' }));
                     continue;
                 }
-                const existingExternalPr = discovered.externalPrNumber ?? (discovered.prNumber > 0 ? discovered.prNumber : 0);
+                const existingPrNumber = discovered.prNumber > 0 ? discovered.prNumber : 0;
                 const terminal = ['COMPLETED', 'CANCELLED'].includes(discovered.state);
-                if (terminal && existingExternalPr <= 0)
+                if (terminal && existingPrNumber <= 0)
                     continue;
                 const sourceSha = await gitText(canonical, ['rev-parse', '--verify', sourceRef]).catch(() => '');
                 if (!sourceSha)
@@ -275,10 +274,10 @@ export async function runDaemon(argv) {
                     }));
                 }
                 let job = (await relay.loadJob(discovered.id)) ?? discovered;
-                let externalPrNumber = job.externalPrNumber ?? (job.prNumber > 0 ? job.prNumber : 0);
-                if (externalPrNumber === 0 && ['COMPLETED', 'CANCELLED'].includes(job.state))
+                let prNumber = job.prNumber > 0 ? job.prNumber : 0;
+                if (prNumber === 0 && ['COMPLETED', 'CANCELLED'].includes(job.state))
                     continue;
-                if (externalPrNumber === 0) {
+                if (prNumber === 0) {
                     // Do not bootstrap an empty remote-only PR commit: it would diverge from
                     // the real local Job branch before its first Worker commit. Publish the
                     // review-only PR when there is an actual diff against main.
@@ -295,17 +294,17 @@ export async function runDaemon(argv) {
                     const pr = await resolvePullRequest(client, job.repository, { head: branch, base, title: job.title, body: job.objective ?? job.description ?? '' });
                     if (!relay.mutateJob)
                         throw new Error('Atomic SQLite mutation is required for GitHub PR binding');
-                    job = await relay.mutateJob(job.id, current => ({ ...current, externalPrNumber: pr.number, updatedAt: new Date().toISOString() }));
-                    externalPrNumber = pr.number;
+                    job = await relay.mutateJob(job.id, current => ({ ...current, prNumber: pr.number, updatedAt: new Date().toISOString() }));
+                    prNumber = pr.number;
                     observability().record({ stage: 'projection', event: 'github.pr_bound', outcome: 'succeeded', message: `Bound local Job ${job.id} to GitHub PR #${pr.number}`, correlation: { repository: job.repository, prNumber: pr.number, jobId: job.id }, data: { head: branch, base } });
                 }
-                if (externalPrNumber <= 0)
+                if (prNumber <= 0)
                     continue;
                 const latestFacts = await relay.loadPullRequestFacts();
                 if (latestFacts?.state !== 'MERGED' && (latestFacts?.head?.sha !== sourceSha || latestFacts?.head?.ref !== branch)) {
                     await relay.savePullRequestFacts({ state: latestFacts?.state === 'CLOSED' ? 'CLOSED' : 'OPEN', head: { ref: branch, sha: sourceSha }, observedAt: new Date().toISOString() });
                 }
-                const github = new GitHubStore(client, job.repository, externalPrNumber, trusted);
+                const github = new GitHubStore(client, job.repository, prNumber, trusted);
                 projectionWriters.set(`job:${job.id}`, new GitHubProjectionWriter(relay, github, undefined, true));
                 if (job.state === 'COMPLETED' && job.localMerge?.status === 'succeeded' && job.localMerge.projectionStrategy === 'target_ref_push') {
                     const injection = await consumeMethodInjection(relay, job.repository, job.id, 'github.projectLocalMerge');
@@ -314,14 +313,14 @@ export async function runDaemon(argv) {
                     // A review-only PR is never merged by GitHub. Close it after local main
                     // has been safely published, retaining the diff, comments and commit link.
                     const remotePr = await github.pullRequestState();
-                    await archiveDisplayPullRequest(client, job.repository, externalPrNumber, job.id, projectedMerge.projectedCommitSha, remotePr);
+                    await archiveDisplayPullRequest(client, job.repository, prNumber, job.id, projectedMerge.projectedCommitSha, remotePr);
                     const projectedState = await github.pullRequestState();
                     const projectedHead = await github.pullRequestHead();
                     await relay.savePullRequestFacts({ state: projectedState, head: projectedHead, observedAt: new Date().toISOString() });
                     observability().record({
                         stage: 'projection', event: 'github.local_merge_projected', outcome: 'succeeded',
                         message: `Projected authoritative local merge ${projectedMerge.localMergedCommitSha} to ${projectedMerge.targetRef}`,
-                        correlation: { repository: job.repository, prNumber: externalPrNumber, jobId: job.id },
+                        correlation: { repository: job.repository, prNumber, jobId: job.id },
                         data: { ...projectedMerge, githubState: projectedState },
                     });
                 }
@@ -334,7 +333,7 @@ export async function runDaemon(argv) {
                 observability().record({
                     stage: 'projection', event: 'github.binding_job_failed', level: 'warn', outcome: 'failed',
                     message: `GitHub binding/projection failed for ${discovered.id}: ${reason}`,
-                    correlation: { repository: discovered.repository, prNumber: discovered.externalPrNumber ?? discovered.prNumber, jobId: discovered.id },
+                    correlation: { repository: discovered.repository, prNumber: discovered.prNumber, jobId: discovered.id },
                     data: { classification, reason },
                 });
             }
@@ -362,7 +361,7 @@ export async function runDaemon(argv) {
     const initial = cachedOverviews;
     const fallback = initial[0]?.job;
     const dashboardStore = fallback ? (await requireLocalJobBinding(fallback.id)).store : new InMemoryStore();
-    const { dashboardOverview, workspaceJobAction, workspaceJobSetState, workspaceTaskCreate, workspaceTaskStart, workspaceTaskComplete, workspaceTaskAction, workspaceTaskSetState } = createDashboardActions({ getOverviews: () => cachedOverviews, requireLocalJobBinding, pool, dashboardJobAction, makeReconciler, concurrency, dashboardJobSetState, refreshAll, applyJobActivateAction, applyOrchestratorStartAction, applyOrchestratorCompleteAction, publishOrchestratorTaskStarted, publishOrchestratorTaskCompletion, bus, dashboardTaskAction, dashboardTaskSetState });
+    const { dashboardOverview, workspaceJobAction, workspaceJobSetState, workspaceTaskCreate, workspaceTaskAction, workspaceTaskSetState } = createDashboardActions({ getOverviews: () => cachedOverviews, requireLocalJobBinding, pool, dashboardJobAction, makeReconciler, concurrency, dashboardJobSetState, refreshAll, applyJobActivateAction, bus, dashboardTaskAction, dashboardTaskSetState });
     const workspaceControl = createWorkspaceControl({ client, trusted, noGitHub, repositories, refreshAll, requireLocalJobBinding, makeReconciler, concurrency, pool, bus, isEffectivelyBlocked, unblockAutonomousTasks, unblockTask, publishTaskUnblocked, dispatchTaskAction, registerBlockerDependency, discoverAgents, ensureManagedGitHubJob });
     const secretFile = value(argv, '--github-webhook-secret-file');
     const secret = noGitHub ? '' : value(argv, '--github-webhook-secret') || process.env.AGENTS_RELAY_GITHUB_WEBHOOK_SECRET || (secretFile ? (await readFile(secretFile, 'utf8')).trim() : '');
@@ -370,7 +369,7 @@ export async function runDaemon(argv) {
         secret,
         repositories: new Set(repositories),
         wake: async (event) => {
-            const targets = cachedOverviews.filter(item => item.job.repository === event.repository && (event.jobId ? item.job.id === event.jobId : (item.job.externalPrNumber ?? item.job.prNumber) === event.pullRequest));
+            const targets = cachedOverviews.filter(item => item.job.repository === event.repository && (event.jobId ? item.job.id === event.jobId : item.job.prNumber === event.pullRequest));
             if (targets.length === 0)
                 return;
             for (const target of targets) {
@@ -429,10 +428,8 @@ export async function runDaemon(argv) {
             const binding = await requireLocalJobBinding(jobId);
             return { store: binding.store, repository: binding.job.repository, prNumber: binding.job.prNumber };
         }, async (_repository, _prNumber, jobId) => pool.reconcileLocalJob(jobId, 'control.task.update')),
-        taskStart: workspaceTaskStart,
         taskRetry: workspaceTaskAction('retry'),
         taskCancel: workspaceTaskAction('cancel'),
-        taskComplete: workspaceTaskComplete,
         taskSetState: workspaceTaskSetState,
     }, async ({ jobId, taskId }) => {
         const overview = cachedOverviews.find(item => item.job.id === jobId);

package/dist/review-generation-fence.js

@@ -5,6 +5,14 @@ export function reviewGenerationMatches(current, original, task, headSha) {
         || (current.headSha && current.headSha !== headSha)
         || fresh.executionId !== task.executionId)
         return false;
+    // A fresh Planner reviewer for a new head replaces the old STALE review
+    // generation. Reject competing reviewers of that same head deterministically.
+    if (current.review?.outcome === 'stale' && original.review?.outcome === 'stale'
+        && current.review.headSha !== headSha && task.planningDecisionId) {
+        const currentHeadReviewers = current.tasks.filter(item => item.agentName === 'reviewer'
+            && item.reviewHeadSha === headSha && item.state !== 'CANCELLED');
+        return currentHeadReviewers.at(-1)?.id === task.id;
+    }
     if (current.review)
         return current.review.taskId === task.id && current.review.headSha === headSha
             && current.review.outcome === (original.review?.outcome ?? 'pending');

package/dist/review-terminal-normalization.js

@@ -0,0 +1,27 @@
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+/** Translate an authenticated reviewer terminal verdict without losing canonical review evidence. */
+export function normalizeReviewerTerminalEvent(event) {
+    if (event.type !== 'task.completed')
+        return null;
+    const data = record(event.data);
+    const raw = data.verdict;
+    const type = raw === 'approved' || raw === 'pass' ? 'review.approved'
+        : raw === 'changes-required' || raw === 'changes_required' ? 'review.changes_required'
+            : raw === 'blocked' ? 'review.blocked' : null;
+    if (!type)
+        return null;
+    const outcome = record(data.outcome);
+    const review = record(data.review);
+    // Match canonical review head resolution: outcome > review > top-level data.
+    const head = [outcome.head_sha, outcome.headSha, review.head_sha, review.headSha,
+        data.head_sha, data.headSha]
+        .find(value => typeof value === 'string' && value.length > 0);
+    const existingFindings = outcome.blocking_findings ?? outcome.blockingFindings;
+    const findings = existingFindings ?? (Array.isArray(data.findings) ? data.findings : undefined);
+    return { ...event, type, data: { ...data, outcome: {
+                ...outcome, ...(head ? { head_sha: head } : {}),
+                ...(findings !== undefined && existingFindings === undefined ? { blocking_findings: findings } : {}),
+            } } };
+}

package/dist/reviewer-thread.js

@@ -42,7 +42,7 @@ export function prepareReviewerThreadDelivery(job, task, override) {
     return {
         kind: 'new-turn', threadId: destination.threadId, threadSource: destination.source,
         requestId: existing?.requestId ?? `${job.id}:${task.id}:${task.reviewHeadSha ?? job.headSha ?? 'review'}`,
-        jobId: job.id, prNumber: job.externalPrNumber && job.externalPrNumber > 0 ? job.externalPrNumber : job.prNumber,
+        jobId: job.id, prNumber: job.prNumber,
         ...(task.reviewHeadSha ? { reviewHeadSha: task.reviewHeadSha } : {}),
         projectId: task.routing?.projectId ?? null,
         ...(existing?.executionId ? { executionId: existing.executionId } : {}),

package/dist/runtime-status.js

@@ -1,5 +1,6 @@
 function isSuperseded(task) {
-    return task.state === 'CANCELLED' && typeof task.error === 'string' && task.error.startsWith('Superseded ');
+    return task.state === 'CANCELLED' && ((task.resolution?.path === 'cancel_supersede' && task.resolution.state === 'resolved')
+        || (typeof task.error === 'string' && task.error.startsWith('Superseded ')));
 }
 export function implementationTasks(job) {
     return job.tasks.filter(task => task.kind !== 'planner'