agents-relay 2.0.81 → 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();

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/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'

package/dist/task-actions.js

@@ -7,8 +7,6 @@ export const TASK_UNBLOCK_RETRY_ACTION = 'task.unblock.retry';
 export const TASK_CANCEL_ACTION = 'task.cancel';
 export const TASK_RELEASE_ACTION = 'task.release';
 export const TASK_HOLD_ACTION = 'task.hold';
-export const TASK_START_ACTION = 'task.start';
-export const TASK_COMPLETE_ACTION = 'task.complete';
 export const TASK_QUEUE_ACTION = 'task.queue';
 function lifecycleRejection(task, action) {
     return new Error(`Task ${task.id} is not ${action} (${task.state})`);
@@ -100,42 +98,6 @@ export async function applyTaskQueueAction(job, task) {
     clearExecution(task);
     return task;
 }
-export async function applyOrchestratorStartAction(task) {
-    if (task.adapter !== 'orchestrator')
-        throw new Error('task start is only valid for adapter=orchestrator self-tasks');
-    const originalState = task.state;
-    try {
-        await transitionTaskEvent(task, 'task.started');
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.startsWith('No enabled workflow transition')) {
-            throw new Error(`Task ${task.id} is ${originalState}; only QUEUED orchestrator tasks can be started`);
-        }
-        throw error;
-    }
-    task.attempt = Math.max(task.attempt, 1);
-    task.updatedAt = new Date().toISOString();
-    return task;
-}
-export async function applyOrchestratorCompleteAction(task, summary) {
-    if (task.adapter !== 'orchestrator')
-        throw new Error('task complete is only valid for adapter=orchestrator self-tasks');
-    const originalState = task.state;
-    if (task.state !== 'RUNNING')
-        throw new Error(`Task ${task.id} is ${originalState}; orchestrator task must be started before completion`);
-    task.result = { summary };
-    clearExecution(task);
-    try {
-        await transitionTaskEvent(task, 'task.completed');
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.startsWith('No enabled workflow transition')) {
-            throw new Error(`Task ${task.id} is ${originalState}; only RUNNING orchestrator tasks can be completed`);
-        }
-        throw error;
-    }
-    return task;
-}
 async function applySelectedRelatedTaskMutations(job, mutations) {
     const changed = [];
     for (const mutation of mutations) {
@@ -148,6 +110,45 @@ async function applySelectedRelatedTaskMutations(job, mutations) {
     }
     return changed;
 }
+function markCancelledTaskSuperseded(task, reason) {
+    if (task.kind === 'planner')
+        throw new Error(`Legacy planner Task ${task.id} is read-only`);
+    if (task.state !== 'CANCELLED')
+        throw new Error(`Task ${task.id} must already be CANCELLED before supersede annotation`);
+    if (!reason.trim())
+        throw new Error('task supersede requires a reason');
+    const proposal = { path: 'cancel_supersede', targetTaskId: task.id, rootCause: reason.trim(), solution: 'Superseded by later corrected durable work' };
+    const decision = dispatchTaskResolutionSync(task, proposal, 'external', { cancelSupersede: () => {
+            task.resolution = { ...materializeResolution(task, proposal, 'external'), state: 'resolved' };
+            task.error = `Superseded ${reason.trim()}`;
+            task.updatedAt = new Date().toISOString();
+        } });
+    if (!decision.accepted)
+        throw new Error(`Task resolution graph rejected cancellation supersede for ${task.id}`);
+}
+export async function supersedeCancelledTask(store, jobId, taskId, reason) {
+    if (store.mutateJob) {
+        let updatedTask;
+        const updated = await store.mutateJob(jobId, current => {
+            const task = current.tasks.find(item => item.id === taskId);
+            if (!task)
+                throw new Error(`Task ${taskId} not found`);
+            markCancelledTaskSuperseded(task, reason);
+            updatedTask = structuredClone(task);
+            return current;
+        });
+        if (!updatedTask)
+            throw new Error(`Task ${taskId} was not updated`);
+        return { job: updated, task: updatedTask };
+    }
+    const job = await store.load(jobId);
+    const task = job.tasks.find(item => item.id === taskId);
+    if (!task)
+        throw new Error(`Task ${taskId} not found`);
+    markCancelledTaskSuperseded(task, reason);
+    await store.saveTask(task);
+    return { job: await store.load(jobId), task };
+}
 /** Compatibility bridge: domain mutation only; adapters own wake/reconcile/output behavior. */
 export async function dispatchTaskAction(store, request) {
     if (store.mutateJob && [TASK_RETRY_ACTION, TASK_RECOVER_ACTION, TASK_CANCEL_ACTION].includes(request.id)) {
@@ -162,8 +163,11 @@ export async function dispatchTaskAction(store, request) {
                     throw new Error(`task recover requires an active Troubleshooter recovery for ${task.id}`);
             }
             const relatedMutations = request.id === TASK_RECOVER_ACTION ? [] : selectRelatedTaskMutations(current, task, request.id);
-            if (request.id === TASK_RETRY_ACTION)
+            if (request.id === TASK_RETRY_ACTION) {
                 applyTaskRetrySnapshot(task, { extendBudget: true });
+                task.routing = undefined;
+                task.workerSelection = undefined;
+            }
             else if (request.id === TASK_RECOVER_ACTION) {
                 const proposal = { path: 'exact_original_retry', targetTaskId: task.id, rootCause: task.failureReason ?? task.error ?? 'durable failure', solution: `Recover exact original Task via ${request.recoveryTaskId}` };
                 const decision = dispatchTaskResolutionSync(task, proposal, 'troubleshooter', { activateRecovery: () => { applyTaskRetrySnapshot(task, { extendBudget: true }); task.resolution = { ...materializeResolution(task, proposal, 'troubleshooter'), state: 'resolved' }; } });
@@ -190,8 +194,11 @@ export async function dispatchTaskAction(store, request) {
     if (!task)
         throw new Error(`Task ${request.taskId} not found`);
     const relatedMutations = request.id === TASK_RECOVER_ACTION ? [] : selectRelatedTaskMutations(job, task, request.id);
-    if (request.id === TASK_RETRY_ACTION)
+    if (request.id === TASK_RETRY_ACTION) {
         await applyTaskRetryAction(task, { extendBudget: true });
+        task.routing = undefined;
+        task.workerSelection = undefined;
+    }
     else if (request.id === TASK_RECOVER_ACTION) {
         const recovery = request.recoveryTaskId ? job.tasks.find(item => item.id === request.recoveryTaskId) : undefined;
         if (!recovery || recovery.agentName !== 'troubleshooter' || recovery.parentTaskId !== task.id || !['QUEUED', 'RUNNING'].includes(recovery.state))
@@ -209,8 +216,6 @@ export async function dispatchTaskAction(store, request) {
         await applyTaskReleaseAction(task);
     else if (request.id === TASK_HOLD_ACTION)
         await applyTaskHoldAction(task);
-    else if (request.id === TASK_START_ACTION)
-        await applyOrchestratorStartAction(task);
     else if (request.id === TASK_QUEUE_ACTION)
         await applyTaskQueueAction(job, task);
     else

package/dist/task-title.js

@@ -0,0 +1,5 @@
+export function deriveTaskTitle(input, fallback = 'Task') {
+    const first = String(input ?? '').split(/\r?\n/).map(line => line.trim()).find(Boolean) ?? fallback;
+    const cleaned = first.replace(/^#{1,6}\s+/, '').replace(/^[-*+]\s+/, '').replace(/^\d+[.)]\s+/, '').replace(/\s+/g, ' ').trim() || fallback;
+    return cleaned.length <= 96 ? cleaned : cleaned.slice(0, 93).trimEnd() + '...';
+}

package/dist/troubleshooter.js

@@ -51,10 +51,10 @@ export function pendingTroubleshooterTasks(job) {
         const id = troubleshooterTaskId(task);
         let create = false;
         const decision = dispatchTroubleshooter({
-            failedOrBlocked: ['FAILED', 'BLOCKED'].includes(task.state),
+            failedWork: task.state === 'FAILED',
             ordinaryWork: task.kind !== 'planner' && task.agentName !== 'troubleshooter',
             currentRun: belongsToCurrentRun(job, task),
-            needsRecovery: !(task.state === 'BLOCKED' && Boolean(task.unblock)),
+            needsRecovery: true,
             idUnused: !existing.has(id),
             noRecoveryBarrier: !hasRecoveryBarrier(job, task),
         }, () => { create = true; });

package/dist/worker-routing.js

@@ -48,7 +48,7 @@ export function usageForProvider(snapshot, provider, now = Date.now()) {
     return {};
 }
 export function workerCandidates(adapters, registered, snapshot) {
-    return adapters.filter(adapter => adapter.name !== 'orchestrator').flatMap(adapter => {
+    return adapters.flatMap(adapter => {
         const workers = registered.filter(worker => worker.runtime.adapter === adapter.name);
         return (workers.length > 0 ? workers : [undefined]).map(worker => {
             const provider = worker?.runtime.provider ?? (adapter.name === 'chatgpt' ? 'chatgpt' : undefined);