agents-relay 2.0.169 → 2.0.171

package/dist/local-authority-store.js

@@ -3,8 +3,6 @@ import { registerBlockerDependency, resolveBlockerDependencies } from './blocker
 import { samePlanDefinition, sameTaskDefinition, DurableDefinitionConflictError, planDefinitionDivergence, taskDefinitionDivergence } from './store-task-definition.js';
 import { mergeInboundJobSnapshot } from './relay-store.js';
 import { publishLocalCommit } from './local-commit-events.js';
-import { decideScheduledRun } from './workflow/scheduled-run-v2.js';
-import { nextScheduleRun, scheduleBucket } from './scheduler.js';
 /**
  * V2 authoritative lifecycle boundary.
  *
@@ -183,61 +181,6 @@ export class LocalAuthorityDurableStore {
         Object.assign(job, structuredClone(updated));
         publishLocalCommit(updated);
     }
-    /** Claim a schedule slot under one SQLite IMMEDIATE transaction, across all processes. */
-    async claimScheduledSlot(jobId, bucket, now) {
-        if (!this.authority.mutateJob)
-            throw new Error('Atomic SQLite schedule claim is required');
-        let status = 'skipped-idempotent';
-        const result = await this.authority.mutateJob(jobId, current => {
-            const schedule = current.schedule;
-            if (!schedule)
-                throw new Error('Scheduled Job ' + jobId + ' has no schedule metadata');
-            const slot = new Date(schedule.nextRunAt);
-            const decision = decideScheduledRun({
-                slotDue: scheduleBucket(slot) === bucket && slot.getTime() <= now.getTime(),
-                slotUnclaimed: !schedule.lastScheduledSlot || new Date(schedule.lastScheduledSlot).getTime() < slot.getTime(),
-                jobActive: current.state === 'ACTIVE',
-                hasActiveTasks: current.tasks.some(task => ['QUEUED', 'RUNNING'].includes(task.state)),
-                concurrencySkip: schedule.concurrencyPolicy === 'skip',
-                concurrencyQueue: schedule.concurrencyPolicy === 'queue',
-                runMissed: schedule.missedRunPolicy === 'run',
-            });
-            const action = decision.accepted ? decision.actions[0]?.id : undefined;
-            if (action === 'schedule.skipActiveAdvance') {
-                schedule.lastScheduledSlot = slot.toISOString();
-                schedule.nextRunAt = nextScheduleRun(schedule, now).toISOString();
-                status = 'skipped-active';
-            }
-            else if (action === 'schedule.claimFromSlot' || action === 'schedule.claimFromNow') {
-                schedule.lastScheduledSlot = slot.toISOString();
-                schedule.currentRunSlot = slot.toISOString();
-                schedule.nextRunAt = nextScheduleRun(schedule, action === 'schedule.claimFromSlot' ? slot : now).toISOString();
-                status = 'completed';
-            }
-            if (status !== 'skipped-idempotent')
-                current.updatedAt = now.toISOString();
-            return current;
-        });
-        if (status !== 'skipped-idempotent')
-            publishLocalCommit(result);
-        return { job: result, status };
-    }
-    /** Persist completion only if this is still the authoritative claimed slot. */
-    async finishScheduledSlot(jobId, slot, now) {
-        if (!this.authority.mutateJob)
-            throw new Error('Atomic SQLite schedule completion is required');
-        const result = await this.authority.mutateJob(jobId, current => {
-            if (current.schedule?.currentRunSlot !== slot)
-                return current;
-            if (!current.schedule.lastRunAt || Date.parse(current.schedule.lastRunAt) < now.getTime()) {
-                current.schedule.lastRunAt = now.toISOString();
-                current.updatedAt = now.toISOString();
-            }
-            return current;
-        });
-        publishLocalCommit(result);
-        return result;
-    }
     async appendPlan(plan) {
         await this.mutate(plan.jobId, job => {
             const existing = (job.plans ?? []).find(item => item.id === plan.id);

package/dist/local-git-merge.js

@@ -3,7 +3,7 @@ import { withLocalMergeLock } from './local-merge-lock.js';
 import { resolve } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import { implementationComplete } from './runtime-status.js';
-import { completionGateSatisfied } from './scheduler.js';
+import { completionGateSatisfied } from './task-transitions.js';
 function git(cwd, ...args) {
     return execFileSync('git', ['-C', cwd, ...args], {
         encoding: 'utf8', timeout: 30000, maxBuffer: 1024 * 1024,
@@ -28,7 +28,6 @@ export function localMergeFacts(job, headSha, now = Date.now) {
     return {
         jobActive: job.state === 'ACTIVE',
         autoMergeEnabled: job.autoMerge !== false,
-        schedulePresent: Boolean(job.schedule),
         implementationComplete: implementationComplete(job),
         completionGateSatisfied: completionGateSatisfied(job),
         reviewSatisfied: job.reviewEnabled === false || job.review?.outcome === 'approved',

package/dist/local-merge-delivery.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { eventFor } from './events.js';
-import { transitionJobEvent } from './scheduler.js';
+import { transitionJobEvent } from './task-transitions.js';
 import { deliverLocalMerge, localMergeFacts } from './local-git-merge.js';
 import { errorMessage } from './observability.js';
 import { decideJobLifecycle } from './workflow/lifecycle.js';

package/dist/markers.js

@@ -1,3 +1,4 @@
+import { currentJobMetadata } from './relay-job-snapshot-reads.js';
 export const JOB_MARKER = 'agents-relay:job:v1';
 export const TASK_MARKER = 'agents-relay:task:v1';
 export const PLAN_MARKER = 'agents-relay:plan:v1';
@@ -35,7 +36,7 @@ function contentBeforeDelimiter(body, heading, end) {
 }
 function jobMetadata(job) {
     const { objective: _objective, description: _description, tasks: _tasks, plans: _plans, ...metadata } = job;
-    return metadata;
+    return currentJobMetadata(metadata);
 }
 export function renderJobBody(job) {
     const objective = job.objective?.trim() || '_No objective recorded._';
@@ -85,11 +86,9 @@ export function parseJob(body) {
     const bodyObjective = markerEnd >= 0 ? body.slice(markerEnd + 3).trim() || undefined : undefined;
     const objective = job.objective ?? job.description ?? contentBeforeDelimiter(body, '\n## Objective\n\n', JOB_OBJECTIVE_END) ?? markdownSection(body, '\n## Objective\n') ?? bodyObjective;
     const parsed = { ...job, objective };
-    if (parsed.executionMode === undefined)
-        return { ...parsed, executionMode: 'fixed' };
-    if (parsed.executionMode !== 'fixed' && parsed.executionMode !== 'autonomous')
-        return null;
-    return parsed;
+    // Historical markers may carry mode/schedule; neither is live Job state.
+    const { executionMode: _legacyMode, schedule: _legacySchedule, ...current } = parsed;
+    return current;
 }
 export function parseTask(body) {
     const task = parseMarker(body, TASK_MARKER);

package/dist/planned-review-head.js

@@ -7,8 +7,8 @@ export async function bindPlannedReviewHead(store, task, localHeadSha) {
         'Review the current immutable local source head as a PRE-MERGE approval gate.',
         'Distinguish code added by this implementation from pre-existing local baseline/seed files present before the Task started.',
         'Preserved baseline files are not automatically extra changes merely because they differ from main; still review them for real risks.',
-        'Do not require a remote PR MERGED, Job COMPLETED, or post-merge E2E evidence before review approval:',
-        'those events must follow approval and are verified by the independent E2E runner.',
+        'Do not require a remote PR MERGED, Job COMPLETED, or post-merge validation before review approval:',
+        'those events must follow approval and require their own verified durable receipts.',
     ].join(' ');
     if (!task.input.includes(rule))
         task.input += '\n\n' + rule;

package/dist/planner-runtime.js

@@ -8,8 +8,8 @@ import { samePlannerChildDefinition } from './planner-child.js';
 import { dispatchJobLifecycleSync } from './workflow/lifecycle.js';
 import { withExecutionBoundary } from './reconciler-runtime.js';
 import { storySizeTimeoutMs } from './types.js';
-import { tryTransitionTaskEvent } from './scheduler.js';
-import { applyPlannerHistoryCleanup, forceRestateConverged } from './force-restate-validation.js';
+import { tryTransitionTaskEvent } from './task-transitions.js';
+import { applyPlannerHistoryCleanup, forceRestateConverged, objectiveSatisfiedForReview } from './force-restate-validation.js';
 import { decideForceRestateValidation } from './workflow/force-restate-validation-v2.js';
 import { workerCandidates } from './worker-routing.js';
 import { createHash } from 'node:crypto';
@@ -268,6 +268,7 @@ export async function finishPlanner(ports, jobId, planId, executionId, error, ra
                 historyConsistencyValid: history.valid,
                 normalHistoryMutationAbsent: !candidatePlan.forceRestate && historyCleanup.length === 0,
                 forwardConvergenceValid: forwardValid,
+                objectiveSatisfied: !plan.forceRestate && objectiveSatisfiedForReview(candidate),
             });
             if (!decision.accepted) {
                 throw new PlannerApplyValidationError('forward_convergence', [`Plan Apply graph rejected the candidate: ${decision.reason}.`]);

package/dist/planner.js

@@ -1,6 +1,5 @@
 import { buildReferenceFirstPrompt, renderAgentPrompt } from './agent-prompt-builder.js';
 import { readFile } from 'node:fs/promises';
-import { parseTestInjection } from './e2e-injection.js';
 import { fileURLToPath } from 'node:url';
 import { dirname, join, resolve as resolvePath } from 'node:path';
 import { storySizeTimeoutMs, taskOverallTimeoutMs } from './types.js';
@@ -31,7 +30,6 @@ function plannerTrigger(job, manual = false) {
     const decision = dispatchPlannerTrigger({
         manualPlan: manual && !hasUnblock,
         hasUnblock,
-        scheduledRun: Boolean(job.schedule?.currentRunSlot),
         initialPlan: (job.plans?.length ?? 0) === 0 && !job.tasks.some(task => task.kind === 'planner'),
     });
     if (!decision.accepted)
@@ -57,8 +55,6 @@ function plannerTrigger(job, manual = false) {
             throw new Error('Planner trigger graph selected unblock without unblock facts');
         return { source: 'unblock', taskIds: cycle.taskIds, reason: cycle.reason, facts: cycle.facts, blockedHeadShas: cycle.baselineHeadShas, currentHeadSha: cycle.currentHeadSha, unblockSource: cycle.source };
     }
-    if (source === 'schedule')
-        return { source: 'schedule' };
     if (source === 'initial')
         return { source: 'initial' };
     return { source: 'continuation' };
@@ -118,14 +114,14 @@ export function materializePlannerChild(job, planner, spec, executionContext) {
             throw new Error(`Planner resolution for ${spec.id} must target one unresolved durable Task`);
     }
     const reviewerThread = spec.agentName === 'reviewer' ? prepareReviewerThreadDelivery(job, { id: spec.id, agentName: spec.agentName, reviewHeadSha }) : undefined, implementationThread = (spec.agentName === 'implementation' || spec.agentName == null) && job.implementationThreadId ? job.implementationThreadId : undefined, threadOwned = Boolean(reviewerThread || implementationThread);
-    return createTaskEntity(job, { jobId: job.id, id: spec.id, title: spec.agentName === 'reviewer' ? 'Review' : 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: objectiveRoot?.id ?? spec.parentTaskId ?? null, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: threadOwned ? chatgptThreadRequirements(spec.workerRequirements) : spec.workerRequirements, testInjection: spec.testInjection, adapter: threadOwned ? 'chatgpt' : (spec.adapter ?? '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.agentName === 'reviewer' ? 'Review' : 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: objectiveRoot?.id ?? spec.parentTaskId ?? null, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: threadOwned ? chatgptThreadRequirements(spec.workerRequirements) : spec.workerRequirements, adapter: threadOwned ? 'chatgpt' : (spec.adapter ?? '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)
         throw new Error(`Initial task ${task.id} requires an output contract`);
     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 };
+    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, 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))
@@ -318,7 +314,6 @@ export function parsePlannerResult(value) {
             id, title: requiredPlannerTaskTitle(task.title, index), 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`),
             adapter: adapter, output: output, routing: route,
             continuation: task.continuation, maxAttempts, timeoutMs, resolution: resolutionProposal(task.resolution, `next_tasks[${index}].resolution`)
         };

package/dist/pool.js

@@ -1,11 +1,10 @@
 import { listManagedGitHubJobs } from './store.js';
 import { eventFor } from './events.js';
-import { runScheduledBucketFromStore } from './scheduled-jobs.js';
-import { scheduleBucket } from './scheduler.js';
 import { ReconcileCoordinator } from './reconcile-coordinator.js';
 import { errorMessage, observability, withObservabilityCorrelation } from './observability.js';
 import { jobHasActiveExecution } from './job-execution-slot.js';
-import { unblockNeedsNewPlan } from './unblock.js';
+import { pendingPlan } from './planner.js';
+import { decidePlannerOrchestration, plannerOrchestrationFacts } from './workflow/planner-orchestration-v2.js';
 import { pendingTroubleshooterRetries } from './troubleshooter.js';
 const RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
 export function compareJobPriority(a, b) { return RANK[a.priority ?? 'P2'] - RANK[b.priority ?? 'P2'] || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id); }
@@ -19,7 +18,9 @@ export function needsLifecycleReconciliation(job, now = Date.now()) {
     if (job.state === 'ACTIVE' && job.localMerge?.status === 'failed' &&
         (!job.localMerge.nextAttemptAt || Date.parse(job.localMerge.nextAttemptAt) <= now))
         return true;
-    if (job.executionMode === 'autonomous' && unblockNeedsNewPlan(job))
+    // The Graph owns continuation eligibility, including restart recovery.
+    const planning = decidePlannerOrchestration(plannerOrchestrationFacts(job, Boolean(pendingPlan(job))));
+    if (planning.accepted && planning.actions.length > 0)
         return true;
     if (pendingTroubleshooterRetries(job).length > 0)
         return true;
@@ -44,7 +45,6 @@ export class RepositoryWorkerPool {
     pending = false;
     reconcileLocks = new Map();
     coordinator;
-    scheduleSignalCoordinator;
     dispatchTail = Promise.resolve();
     watchedBus;
     constructor(concurrency, makeReconciler, localInventory, resolveLocalJob) {
@@ -61,7 +61,6 @@ export class RepositoryWorkerPool {
             });
         };
         this.coordinator = new ReconcileCoordinator((jobId, signals) => this.consumeSignals(jobId, signals), reportCoordinatorError);
-        this.scheduleSignalCoordinator = new ReconcileCoordinator((jobId, signals) => this.consumeScheduleSignals(jobId, signals), reportCoordinatorError);
     }
     async localTarget(jobId) {
         return this.resolveLocalJob(jobId);
@@ -107,20 +106,6 @@ export class RepositoryWorkerPool {
         }
         return `event.${event.type}`;
     }
-    async consumeScheduleSignals(jobId, signals) {
-        const event = [...signals].reverse().find(item => item.event?.type === 'schedule.tick')?.event;
-        const bucket = typeof event?.data?.bucket === 'string' ? event.data.bucket : null;
-        const tickAt = new Date(typeof event?.data?.tickAt === 'string' ? event.data.tickAt : event?.timestamp ?? Date.now());
-        if (!bucket || Number.isNaN(tickAt.getTime()))
-            return;
-        const target = await this.localTarget(jobId);
-        if (!target)
-            return;
-        await runScheduledBucketFromStore(target.store, { jobId, bucket }, {
-            reconcile: async () => this.reconcileLocalJob(jobId, 'schedule.tick'),
-            idle: async () => { },
-        }, tickAt);
-    }
     async reconcileLocalJob(jobId, reason = 'local.request') {
         const target = await this.localTarget(jobId);
         if (!target)
@@ -164,7 +149,8 @@ export class RepositoryWorkerPool {
             const expiredRunning = job.tasks.some(task => ['RUNNING', 'QUEUED'].includes(task.state) && task.executionId !== null && task.leaseExpiresAt !== null && new Date(task.leaseExpiresAt).getTime() <= Date.now());
             if (!needsLifecycleReconciliation(job))
                 continue;
-            const allowance = Math.max(1, Math.min(capacity, ready || (expiredRunning ? 1 : 0) || 1));
+            // A Graph-selected Planner continuation does not reserve a Task worker slot.
+            const allowance = ready || expiredRunning ? Math.max(1, Math.min(capacity, ready || 1)) : 0;
             try {
                 await this.reconcileExclusive(job.id, async () => {
                     await this.makeReconciler(store, allowance).reconcile(job.id);
@@ -227,10 +213,6 @@ export class RepositoryWorkerPool {
         const unsubscribe = await bus.subscribeAll(async (event) => {
             const routedWebhook = event.type === 'github.webhook' && event.data?.coordinatorRouted === true;
             const ingressWebhook = event.type === 'github.webhook' && event.data?.coordinatorIngress === true && !routedWebhook;
-            if (event.type === 'schedule.tick') {
-                await this.scheduleSignalCoordinator.acceptTransport({ jobId: event.job_id, reason: this.signalReason(event), event });
-                return;
-            }
             if (ingressWebhook)
                 return;
             if (routedWebhook)
@@ -254,17 +236,6 @@ export class RepositoryWorkerPool {
                 this.watchedBus = undefined;
         };
     }
-    async scheduleTickSignal(bus, job, now = new Date()) {
-        if (!job.schedule)
-            return;
-        const event = eventFor(job.id, 'scheduler', null, 'schedule.tick', 'queued', `Schedule tick for ${job.schedule.nextRunAt}`, 'orchestrator', { bucket: scheduleBucket(new Date(job.schedule.nextRunAt)), tickAt: now.toISOString() }, { agent: 'relay', component: 'scheduler-timer' });
-        // Use the same coordinator-owned schedule path whether transport is available or not.
-        if (bus) {
-            await bus.publish(event);
-            return;
-        }
-        await this.scheduleSignalCoordinator.accept({ jobId: job.id, reason: this.signalReason(event), event });
-    }
     async webhookSignal(_bus, _wake) {
         // Uncorrelated webhook wakeups are intentionally ignored. A caller must first
         // resolve the target from local cached state and then call webhookWake().

package/dist/reconciler-review.js

@@ -1,5 +1,5 @@
 import { storySizeTimeoutMs, taskOverallTimeoutMs } from './types.js';
-import { completionGateSatisfied, schedule, transitionTaskEvent, tryTransitionTaskEvent } from './scheduler.js';
+import { completionGateSatisfied, refreshTaskDependencies, transitionTaskEvent, tryTransitionTaskEvent } from './task-transitions.js';
 import { implementationComplete, implementationTasks } from './runtime-status.js';
 import { eventFor } from './events.js';
 import { workerCandidates } from './worker-routing.js';
@@ -37,7 +37,6 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const reviewTasks = job.tasks.filter(task => task.agentName === 'reviewer' && task.reviewHeadSha === headSha);
         const currentReviewTask = job.review?.taskId ? job.tasks.find(task => task.id === job.review?.taskId) : undefined;
         return {
-            unscheduled: !job.schedule,
             reviewEnabled: job.reviewEnabled !== false,
             jobActive: job.state === 'ACTIVE' || job.projectionRecovery?.status === 'repairing',
             implementationComplete: implementationComplete(job),
@@ -149,7 +148,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             'Review the complete PR diff at this exact immutable head SHA, not only the dependency Tasks.',
             'Use the selected reviewer agent contract as the authoritative review protocol.',
             'This is a PRE-MERGE artifact approval gate: inspect exact PR head, requirements, tests and genuine blocking defects.',
-            'Do not block approval because automatic merge, Job COMPLETED, or post-merge E2E evidence has not occurred yet.',
+            'Do not block approval because automatic merge, Job COMPLETED, or post-merge validation has not occurred yet.',
             'Do not treat historical failed attempts as current artifact defects; distinguish preserved baseline files from implementation.',
         ].join('\n\n');
         const task = createTaskEntity(job, {
@@ -213,7 +212,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         job.review = { outcome, headSha, taskId: reviewTaskId, evidence: null, updatedAt: now };
         job.updatedAt = now;
         await this.store.saveJob(job);
-        const ready = schedule(await this.store.load(job.id));
+        const ready = refreshTaskDependencies(await this.store.load(job.id));
         await this.store.saveJob(ready);
     }
     async selectReviewer(implementationTasks, requirementsOverride) {
@@ -290,7 +289,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             job: {
                 id: job.id, title: job.title, objective: job.objective ?? null,
                 description: job.description ?? null, priority: job.priority ?? null,
-                executionMode: job.executionMode, repository: job.repository,
+                repository: job.repository,
                 prNumber: this.externalReviewPrNumber(job), state: job.state,
             },
             task: {

package/dist/reconciler.js

@@ -5,12 +5,11 @@ import { drainProductionWorkflowOutbox } from './reconciler-workflow-outbox.js';
 import { cancelPausedGenerations } from './reconciler-pause.js';
 import { taskCommentContext } from './task-comments.js';
 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 { dependencyReady, refreshTaskDependencies, transitionTaskEvent } from './task-transitions.js';
 import { applyTaskRetryAction } from './task-actions.js';
 import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
@@ -57,7 +56,7 @@ export class Reconciler extends ReconcilerReviewBase {
         this.workflowEffects.register(new CallbackWorkflowEffectHandler('effect.cleanupJobWorktree', async (context) => cleanupMergedJobWorktree(await this.store.load(context.jobId), this.options.projectPathForJob), context => `effect.cleanupJobWorktree:${context.jobId}`));
     }
     async dispatchExecutableTasks(jobId) {
-        const scheduled = schedule(await this.store.load(jobId));
+        const scheduled = refreshTaskDependencies(await this.store.load(jobId));
         if (scheduled.pause)
             return scheduled;
         for (const task of scheduled.tasks.filter(item => item.state === 'SUCCEEDED' && (item.continuation || scheduled.continuation) && !item.continuationDeliveredAt)) {
@@ -78,7 +77,7 @@ export class Reconciler extends ReconcilerReviewBase {
                 await this.applyTaskEffectOutcomes(scheduled, task, outcomes);
             }, async () => { await this.store.saveTask(task); });
         }
-        return schedule(await this.store.load(jobId));
+        return refreshTaskDependencies(await this.store.load(jobId));
     }
     async reconcile(jobId) {
         if (this.reconciling)
@@ -174,8 +173,7 @@ export class Reconciler extends ReconcilerReviewBase {
                 }
             const beforeSchedule = await this.store.load(jobId);
             const taskStatesBeforeSchedule = new Map(beforeSchedule.tasks.map(task => [task.id, task.state]));
-            const scheduleBefore = JSON.stringify(beforeSchedule.schedule ?? null);
-            let scheduled = schedule(beforeSchedule);
+            let scheduled = refreshTaskDependencies(beforeSchedule);
             for (const task of scheduled.tasks)
                 if (task.executionId && ['QUEUED', 'RUNNING'].includes(task.state))
                     this.armInactivityWatchdog(task, task.executionId);
@@ -183,19 +181,17 @@ export class Reconciler extends ReconcilerReviewBase {
                 if (taskStatesBeforeSchedule.get(task.id) !== task.state)
                     await this.store.saveTask(task);
             }
-            if (scheduled.state !== previousState || JSON.stringify(scheduled.schedule ?? null) !== scheduleBefore)
+            if (scheduled.state !== previousState)
                 await this.store.saveJob(scheduled);
             {
                 await this.ensureFinalReview(scheduled, headSha);
-                scheduled = schedule(await this.store.load(jobId));
-            }
-            if (scheduled.executionMode === 'autonomous' || (scheduled.plans ?? []).some(plan => plan.forceRestate && plan.status === 'FAILED')) {
-                scheduled = schedule(await this.maybeCreatePlanner(scheduled));
+                scheduled = refreshTaskDependencies(await this.store.load(jobId));
             }
+            scheduled = refreshTaskDependencies(await this.maybeCreatePlanner(scheduled));
             if (scheduled.state !== previousState || scheduled.updatedAt !== job.updatedAt)
                 await this.store.saveJob(scheduled);
             scheduled = await this.dispatchExecutableTasks(jobId);
-            let finalState = schedule(await this.store.load(jobId));
+            let finalState = refreshTaskDependencies(await this.store.load(jobId));
             if (finalState.updatedAt !== scheduled.updatedAt)
                 await this.store.saveJob(finalState);
             await this.ensureFinalReview(finalState, headSha);
@@ -277,6 +273,9 @@ export class Reconciler extends ReconcilerReviewBase {
         return executeManualPlan(this.store, jobId, guidance, this.options.plannerTimeoutMs ?? storySizeTimeoutMs('M'), (job, plan) => this.launchPlanner(job, plan, true));
     }
     async maybeCreatePlanner(job) {
+        // Terminal Jobs can repair projections and re-review, but must not reopen planning.
+        if (job.state !== 'ACTIVE')
+            return job;
         const pending = pendingPlan(job);
         const recoverable = pending && !this.plannerLive.has(pending.id)
             && (!pending.executionId || pending.leaseOwner !== this.options.owner || !pending.leaseExpiresAt || Date.parse(pending.leaseExpiresAt) <= (this.options.now ?? new Date()).getTime())
@@ -470,31 +469,7 @@ 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;
-        const declaration = authorizedInjection(job.repository, task.testInjection);
-        if (task.testInjection && !declaration) {
-            await this.failLaunch(job.id, task.id, durableExecutionId, `E2E test injection refused for repository ${job.repository}; configure E2E_REPO on relayd`, 'delivery');
-            return;
-        }
-        const workerCheckpoint = declaration?.method === 'worker.codex.launch' || declaration?.method === 'browserWorkspace.command';
-        const testInjection = workerCheckpoint && ((task.adapter === 'codex' && declaration.method === 'worker.codex.launch') || (task.adapter === 'chatgpt' && declaration.method === 'browserWorkspace.command')) ? declaration : undefined;
-        if (workerCheckpoint && !testInjection) {
-            await this.failLaunch(job.id, task.id, durableExecutionId, `E2E test injection ${declaration.method} is incompatible with adapter ${task.adapter}`, 'delivery');
-            return;
-        }
-        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/relay-create.js

@@ -1,13 +1,13 @@
-import { normalizeLegacyJobPrNumber } from './job-pr-number-migration.js';
+import { currentJobMetadata, normalizeRelayJob } from './relay-job-snapshot-reads.js';
 export function createJobIfAbsent(db, job) {
     db.exec('BEGIN IMMEDIATE');
     try {
         const row = db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(job.id);
         if (row?.json) {
             db.exec('COMMIT');
-            return normalizeLegacyJobPrNumber(JSON.parse(row.json));
+            return normalizeRelayJob(row.json);
         }
-        db.prepare('INSERT INTO job_snapshot(job_id,json,updated_at) VALUES(?,?,?)').run(job.id, JSON.stringify(job), new Date().toISOString());
+        db.prepare('INSERT INTO job_snapshot(job_id,json,updated_at) VALUES(?,?,?)').run(job.id, JSON.stringify(currentJobMetadata(job)), new Date().toISOString());
         db.exec('COMMIT');
         return structuredClone(job);
     }

package/dist/relay-job-snapshot-reads.js

@@ -1,8 +1,12 @@
 import { normalizeLegacyTaskLifecycle } from './types.js';
 import { normalizeLegacyJobPrNumber } from './job-pr-number-migration.js';
+export function currentJobMetadata(job) {
+    const { executionMode: _mode, schedule: _schedule, ...current } = job;
+    return current;
+}
 export function normalizeRelayJob(json) {
-    const job = normalizeLegacyJobPrNumber(JSON.parse(json));
-    job.tasks = job.tasks.map(t => normalizeLegacyTaskLifecycle(t, job.executionMode));
+    const job = currentJobMetadata(normalizeLegacyJobPrNumber(JSON.parse(json)));
+    job.tasks = job.tasks.map(t => normalizeLegacyTaskLifecycle(t));
     job.plans = (job.plans ?? []).map(plan => {
         const legacy = plan;
         if (plan.forceRestate === undefined && legacy.forceCleanHistory === true)

package/dist/relay-store.js

@@ -1,4 +1,4 @@
-import { loadRelayJob, listRelayJobs } from './relay-job-snapshot-reads.js';
+import { currentJobMetadata, loadRelayJob, listRelayJobs } from './relay-job-snapshot-reads.js';
 import { SQLiteWorkflowOperations } from './relay-workflow-operations.js';
 import { preserveTaskComments } from './task-comments.js';
 import { DatabaseSync } from 'node:sqlite';
@@ -242,7 +242,7 @@ export class SQLiteRelayStore {
         this.db.prepare(`
       INSERT INTO job_snapshot(job_id,json,updated_at) VALUES(?,?,?)
       ON CONFLICT(job_id) DO UPDATE SET json=excluded.json, updated_at=excluded.updated_at
-    `).run(job.id, JSON.stringify(job), now);
+    `).run(job.id, JSON.stringify(currentJobMetadata(job)), now);
     }
     async loadAgents() {
         const observed = this.scopeJobId

package/dist/relay-workflow-operations.js

@@ -52,7 +52,7 @@ export class SQLiteWorkflowOperations {
             if (!row?.json)
                 throw new Error(`Unknown Job ${jobId}`);
             const current = normalizeRelayJob(row.json);
-            current.tasks = current.tasks.map(task => normalizeLegacyTaskLifecycle(task, current.executionMode));
+            current.tasks = current.tasks.map(task => normalizeLegacyTaskLifecycle(task));
             const previous = structuredClone(current);
             const next = mutation(current);
             if (next.id !== jobId)
@@ -121,7 +121,7 @@ export class SQLiteWorkflowOperations {
             if (!row?.json)
                 throw new Error(`Local authoritative Job ${jobId} not found`);
             const current = normalizeRelayJob(row.json);
-            current.tasks = current.tasks.map(task => normalizeLegacyTaskLifecycle(task, current.executionMode));
+            current.tasks = current.tasks.map(task => normalizeLegacyTaskLifecycle(task));
             const previous = structuredClone(current);
             const before = JSON.stringify(current);
             const next = mutation(current);

package/dist/relayd-control.js

@@ -8,7 +8,7 @@ import { classifyFailedTask, supersedeCancelledTask } from './task-actions.js';
 import { requestTroubleshooterEscalation, resumeTroubleshooter } from './task-recovery.js';
 import { adoptExistingPullRequestJob } from './cli-job-create.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 { client, trusted, noGitHub, repositories, refreshAll, requireLocalJobBinding, makeReconciler, concurrency, pool, bus, isEffectivelyBlocked, 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 : '';
@@ -19,6 +19,8 @@ export function createWorkspaceControl(deps) {
             const options = (body.options && typeof body.options === 'object' ? body.options : {});
             if (!repository)
                 throw new Error('job.create requires repository');
+            if ('executionMode' in options || 'schedule' in options)
+                throw new Error('Job execution modes and schedules are unsupported');
             const result = await ensureManagedGitHubJob(client, repository, trusted, {
                 id: typeof options.id === 'string' && options.id ? options.id : undefined,
                 idempotencyKey: typeof options.idempotencyKey === 'string' ? options.idempotencyKey : undefined,
@@ -26,8 +28,6 @@ export function createWorkspaceControl(deps) {
                 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,
@@ -44,7 +44,7 @@ export function createWorkspaceControl(deps) {
                 const current = result.job;
                 const existingPlan = current.plans?.at(-1);
                 if (existingPlan)
-                    return { repository, pr: result.pr.number, job: current.id, executionMode: current.executionMode, state: current.state, initialPlan: existingPlan.id, reused: true };
+                    return { repository, pr: result.pr.number, job: current.id, state: current.state, initialPlan: existingPlan.id, reused: true };
                 const unpublished = new InMemoryStore(current);
                 const reconciler = makeReconciler(unpublished, concurrency);
                 try {
@@ -60,13 +60,13 @@ export function createWorkspaceControl(deps) {
                         unpublishedStore.relay.close();
                     }
                     await pool.reconcileLocalJob(result.job.id, 'control.job.create.initial-plan');
-                    return { repository, pr: committed.prNumber, job: committed.id, executionMode: committed.executionMode, state: committed.state, initialPlan: committed.plans?.at(-1)?.id };
+                    return { repository, pr: committed.prNumber, job: committed.id, state: committed.state, initialPlan: committed.plans?.at(-1)?.id };
                 }
                 finally {
                     await reconciler.close();
                 }
             }
-            return { repository, pr: result.pr.number, job: result.job.id, executionMode: result.job.executionMode, state: result.job.state };
+            return { repository, pr: result.pr.number, job: result.job.id, state: result.job.state };
         }
         if (command === 'job.adopt') {
             const repository = typeof body.repository === 'string' ? body.repository : '';
@@ -91,7 +91,9 @@ export function createWorkspaceControl(deps) {
         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', 'implementationThreadId', 'continuation', 'localMerge'];
+            if ('executionMode' in patch || 'schedule' in patch)
+                throw new Error('Job execution modes and schedules are unsupported');
+            const mutable = ['title', 'objective', 'projectPath', 'priority', 'tag', 'autoMerge', 'reviewEnabled', 'reviewerThreadId', 'creatorThreadId', 'implementationThreadId', 'continuation', 'localMerge'];
             for (const key of mutable)
                 if (Object.prototype.hasOwnProperty.call(patch, key)) {
                     const value = patch[key];

package/dist/relayd-utilities.js

@@ -26,10 +26,6 @@ export function mergeOperationalInventory(current, discovered) {
     return [...merged.values()];
 }
 const PR_REFRESH_COALESCE_MS = 1000;
-export const SCHEDULE_HEARTBEAT_MS = 600_000;
-export function dueScheduledOverviews(overviews, now = new Date()) {
-    return overviews.filter(item => item.job.state === 'ACTIVE' && item.job.executionMode === 'autonomous' && item.job.schedule && Date.parse(item.job.schedule.nextRunAt) <= now.getTime());
-}
 export function shouldCoalescePullRequestRefresh(completedAt, now = Date.now(), force = false) {
     return !force && completedAt !== null && now >= completedAt && now - completedAt < PR_REFRESH_COALESCE_MS;
 }