agents-relay 2.0.169 → 2.0.171

package/dist/relayd.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import { escalationNotifierFromEnvironment } from './escalation-notifier.js';
-import { consumeMethodInjection, withTestInjection } from './e2e-injection.js';
 import { once } from 'node:events';
 import { spawnOwnedProcess } from './owned-process.js';
 import { readFile } from 'node:fs/promises';
@@ -28,7 +27,7 @@ import { dashboardJobAction, isEntrypoint, runtimePlanner, runtimeReviewer, star
 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 { isEffectivelyBlocked, unblockTask } from './unblock.js';
 import { registerBlockerDependency } from './blockers.js';
 import { ensureManagedGitHubJob } from './cli-job-create.js';
 import { applyJobActivateAction } from './job-actions.js';
@@ -49,8 +48,8 @@ import { routeExecution } from './execution-routing.js';
 import { classifyFailure, errorMessage, observability } from './observability.js';
 import { createWorkspaceControl } from './relayd-control.js';
 import { createDashboardActions } from './relayd-dashboard-actions.js';
-export { daemonHelp, normalizeDaemonArguments, overlayOperationalOverviews, mergeOperationalInventory, recoveryScanRepositories, shouldCoalescePullRequestRefresh, SCHEDULE_HEARTBEAT_MS, dueScheduledOverviews, configureExecutionRouterRulesPath } from './relayd-utilities.js';
-import { configureDaemonObservability, firstStageChoices, value, daemonHelp, normalizeDaemonArguments, SCHEDULE_HEARTBEAT_MS, dueScheduledOverviews, configureExecutionRouterRulesPath } from './relayd-utilities.js';
+export { daemonHelp, normalizeDaemonArguments, overlayOperationalOverviews, mergeOperationalInventory, recoveryScanRepositories, shouldCoalescePullRequestRefresh, configureExecutionRouterRulesPath } from './relayd-utilities.js';
+import { configureDaemonObservability, firstStageChoices, value, daemonHelp, normalizeDaemonArguments, configureExecutionRouterRulesPath } from './relayd-utilities.js';
 export async function runDaemon(argv) {
     if (argv.includes('--help') || argv.includes('-h')) {
         console.log(daemonHelp);
@@ -323,7 +322,7 @@ export async function runDaemon(argv) {
                 if (job.state === 'COMPLETED' && job.localMerge?.status === 'succeeded' && job.localMerge.projectionStrategy === 'target_ref_push') {
                     const projection = await projectBindingLocalMerge(job, relay, {
                         projectPath: canonical,
-                        project: async (projectedJob) => withTestInjection('github.projectLocalMerge', await consumeMethodInjection(relay, job.repository, job.id, 'github.projectLocalMerge'), () => projectAuthoritativeLocalMerge(canonical, projectedJob)),
+                        project: async (projectedJob) => projectAuthoritativeLocalMerge(canonical, projectedJob),
                         verifyObservedRemote: async (sha) => {
                             try {
                                 await gitText(canonical, ['merge-base', '--is-ancestor', sha, 'refs/heads/main']);
@@ -384,7 +383,7 @@ export async function runDaemon(argv) {
     const fallback = initial[0]?.job;
     const dashboardStore = fallback ? (await requireLocalJobBinding(fallback.id)).store : new InMemoryStore();
     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 workspaceControl = createWorkspaceControl({ client, trusted, noGitHub, repositories, refreshAll, requireLocalJobBinding, makeReconciler, concurrency, pool, bus, isEffectivelyBlocked, 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() : '');
     const webhook = secret ? {
@@ -474,7 +473,7 @@ export async function runDaemon(argv) {
                 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: job.prNumber, state: job.state,
                 },
                 task: {
@@ -525,17 +524,6 @@ export async function runDaemon(argv) {
             observability().record({ stage: 'daemon', event: 'daemon.reconcile_failed', level: 'warn', outcome: 'failed', message: `Workspace reconcile unavailable: ${errorMessage(error)}`, data: { classification: classifyFailure(error).classification, reason: errorMessage(error) } });
         }
     };
-    const scheduleHeartbeatSafely = async () => {
-        const now = new Date();
-        for (const item of dueScheduledOverviews(cachedOverviews, now)) {
-            try {
-                await pool.scheduleTickSignal(bus, item.job, now);
-            }
-            catch (error) {
-                observability().record({ stage: 'daemon', event: 'daemon.schedule_heartbeat_failed', level: 'warn', outcome: 'failed', message: `Scheduled heartbeat unavailable: ${errorMessage(error)}`, correlation: { repository: item.job.repository, prNumber: item.job.prNumber, jobId: item.job.id }, data: { classification: classifyFailure(error).classification, reason: errorMessage(error) } });
-            }
-        }
-    };
     const flushProjectionsSafely = async () => {
         let externalActionsCompleted = 0;
         for (const writer of projectionWriters.values()) {
@@ -552,18 +540,15 @@ export async function runDaemon(argv) {
     };
     const watchdogDefault = webhook ? SERVICE_DEFAULTS.webhookWatchdogMs : SERVICE_DEFAULTS.watchdogMs;
     let interval;
-    let scheduleInterval;
     let projectionInterval;
     const stop = () => { stopRuntimeStatusEvents(); if (interval)
-        clearInterval(interval); if (scheduleInterval)
-        clearInterval(scheduleInterval); if (projectionInterval)
+        clearInterval(interval); if (projectionInterval)
         clearInterval(projectionInterval); void Promise.allSettled([stopWatch(), shutdownOwnedProcesses('parent-shutdown')]).finally(() => { for (const store of relayStores.values())
         store.close(); server.close(() => process.exit(0)); }); };
     process.once('SIGINT', stop);
     process.once('SIGTERM', stop);
     await syncGitHubBindingsSafely();
     await pool.reconcileKnown(cachedOverviews);
-    await scheduleHeartbeatSafely();
     await flushProjectionsSafely();
     interval = setInterval(() => void reconcileSafely().finally(flushProjectionsSafely), Number(value(argv, '--interval', String(watchdogDefault))));
     interval.unref();
@@ -571,8 +556,6 @@ export async function runDaemon(argv) {
         projectionInterval = setInterval(() => void syncGitHubBindingsSafely().then(flushProjectionsSafely), Number(value(argv, '--projection-ms', String(SERVICE_DEFAULTS.projectionFlushMs))));
         projectionInterval.unref();
     }
-    scheduleInterval = setInterval(() => void scheduleHeartbeatSafely(), SCHEDULE_HEARTBEAT_MS);
-    scheduleInterval.unref();
     console.log('Dashboard listening; repository worker pool active');
     void refreshAll(true)
         .then(items => pool.reconcileKnown(items))

package/dist/runtime-status.js

@@ -26,23 +26,6 @@ export function deriveJobRuntimeStatus(job, _prState = 'OPEN') {
     // Active task execution still takes precedence below.
     const plannerFailed = currentPlan?.status === 'FAILED' && !job.tasks.some(task => ['QUEUED', 'RUNNING'].includes(task.state));
     const plannerRunning = currentPlan?.status === 'PLANNING';
-    if (job.schedule) {
-        if (job.tasks.some(task => task.state === 'RUNNING'))
-            return 'RUNNING';
-        if (job.tasks.some(task => task.state === 'QUEUED'))
-            return 'QUEUED';
-        if (job.tasks.some(task => task.state === 'BLOCKED'))
-            return 'BLOCKED';
-        if (job.tasks.some(task => task.state === 'FAILED'))
-            return 'FAILED';
-        if (job.tasks.some(task => task.state === 'DRAFT'))
-            return 'WAITING';
-        if (plannerFailed)
-            return 'FAILED';
-        if (plannerRunning)
-            return 'RUNNING';
-        return 'WAITING';
-    }
     // Draft or queued reviewers must not mask implementation that is still active.
     const implementation = implementationTasks(job);
     if (implementation.some(task => task.state === 'RUNNING'))
@@ -68,8 +51,6 @@ export function deriveJobRuntimeStatus(job, _prState = 'OPEN') {
         return 'FAILED';
     if (plannerRunning)
         return 'RUNNING';
-    if (job.executionMode === 'autonomous' && job.autoMerge === false && job.reviewEnabled === false && implementationComplete(job))
-        return 'WAITING';
     if (job.reviewEnabled === false && implementationComplete(job))
         return 'MERGE_PENDING';
     return 'IDLE';

package/dist/single-job-task-control.js

@@ -14,7 +14,7 @@ export async function createSingleJobTaskControl(jobId, store, reconciler, bus)
                 await reconciler.idle();
             } },
         bus, isEffectivelyBlocked: unblock.isEffectivelyBlocked,
-        unblockAutonomousTasks: unblock.unblockAutonomousTasks, unblockTask: unblock.unblockTask,
+        unblockTask: unblock.unblockTask,
         publishTaskUnblocked, dispatchTaskAction,
     });
     const allowed = new Set(['task.unblock', 'task.recover', 'task.escalate', 'task.resume-troubleshooter', 'task.classify']);

package/dist/store.js

@@ -92,7 +92,7 @@ export class InMemoryStore {
         }
     }
     async load(jobId) { const job = await this.findJob(jobId); if (!job)
-        throw new Error(`Job ${jobId} not found`); job.plans = this.plansForJob(jobId); job.tasks = this.tasksForJob(jobId).map(task => normalizeLegacyTaskLifecycle(task, job.executionMode)); return job; }
+        throw new Error(`Job ${jobId} not found`); job.plans = this.plansForJob(jobId); job.tasks = this.tasksForJob(jobId).map(task => normalizeLegacyTaskLifecycle(task)); return job; }
     async mutateJob(jobId, mutation) {
         const current = await this.load(jobId);
         const next = mutation(structuredClone(current));

package/dist/task-actions.js

@@ -1,4 +1,4 @@
-import { extendRetryBudget, transitionTaskEvent, tryTransitionTaskEvent } from './scheduler.js';
+import { extendRetryBudget, transitionTaskEvent, tryTransitionTaskEvent } from './task-transitions.js';
 import { selectRelatedTaskMutations } from './workflow/task-action-policy.js';
 import { dispatchTaskResolutionSync, materializeResolution } from './workflow/task-resolution.js';
 import { classifyTaskResolution } from './workflow/task-resolution.js';
@@ -59,7 +59,7 @@ function applyTaskRetrySnapshot(task, policy = {}) {
 }
 /** Fixed-job authoritative unblock continuation, applied inside one Job snapshot mutation. */
 export function applyTaskUnblockRetrySnapshot(task) {
-    if (task.state === 'BLOCKED' && !tryTransitionTaskEvent(task, 'task.unblocked', { autonomousJob: false }).accepted)
+    if (task.state === 'BLOCKED' && !tryTransitionTaskEvent(task, 'task.unblocked', {}).accepted)
         throw lifecycleRejection(task, 'retryable after unblock');
     if (!['QUEUED', 'DRAFT'].includes(task.state))
         throw lifecycleRejection(task, 'retryable after unblock');
@@ -81,7 +81,7 @@ export async function applyTaskRetryAction(task, policy = {}) {
 /** Fixed-job authoritative unblock continuation: legality is owned by the lifecycle graph. */
 export async function applyTaskUnblockRetryAction(task) {
     if (task.state === 'BLOCKED')
-        await transitionTaskAction(task, 'task.unblocked', 'retryable after unblock', { autonomousJob: false });
+        await transitionTaskAction(task, 'task.unblocked', 'retryable after unblock', {});
     if (!['QUEUED', 'DRAFT'].includes(task.state))
         throw lifecycleRejection(task, 'retryable after unblock');
     task.attempt = 0;

package/dist/task-recovery.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { eventFor } from './events.js';
-import { tryTransitionTaskEvent } from './scheduler.js';
+import { tryTransitionTaskEvent } from './task-transitions.js';
 import { dispatchTaskResolutionSync, materializeResolution } from './workflow/task-resolution.js';
 function activeRecovery(job, original) {
     return job.tasks.find(task => task.agentName === 'troubleshooter'
@@ -112,7 +112,7 @@ export async function resumeTroubleshooter(store, jobId, recoveryTaskId, respons
             throw new Error(`Escalation ${task.escalation.id} already has a response`);
         if (task.state !== 'BLOCKED')
             throw new Error(`Task ${recoveryTaskId} is not a blocked Troubleshooter escalation`);
-        if (!tryTransitionTaskEvent(task, 'task.unblocked', { autonomousJob: false }).accepted)
+        if (!tryTransitionTaskEvent(task, 'task.unblocked', {}).accepted)
             throw new Error(`Troubleshooter ${recoveryTaskId} cannot be resumed`);
         task.escalation = { ...task.escalation, status: 'responded', response: response.trim(), respondedAt: now };
         task.result = null;

package/dist/task-transitions.js

@@ -0,0 +1,61 @@
+import { implementationTasks } from './runtime-status.js';
+import { dispatchJobLifecycle, dispatchTaskLifecycle, dispatchTaskLifecycleSync } from './workflow/lifecycle.js';
+import { reconcileTaskDependencies } from './workflow/task-reconcile.js';
+export { dependencyReady, detectCycles } from './workflow/task-reconcile.js';
+import { observability } from './observability.js';
+export function completionGateSatisfied(job) {
+    const latest = [...(job.plans ?? [])].sort((a, b) => a.round - b.round).at(-1);
+    const planSatisfied = latest?.status === 'SUCCEEDED' && latest.objectiveStatus === 'satisfied';
+    const legacySatisfied = (job.plans?.length ?? 0) === 0 && job.tasks.some(task => task.kind === 'planner' && task.state === 'SUCCEEDED' && task.plannerResult?.objective_status === 'satisfied');
+    const implementation = implementationTasks(job);
+    return (planSatisfied || legacySatisfied) && implementation.length > 0 && implementation.every(task => task.state === 'SUCCEEDED');
+}
+export function refreshTaskDependencies(job) {
+    if (job.pause)
+        return job;
+    reconcileTaskDependencies(job);
+    return job;
+}
+export function extendRetryBudget(task, windowSize = 3) {
+    if (!Number.isInteger(windowSize) || windowSize < 1)
+        throw new Error('Retry window size must be a positive integer');
+    const usedOrBudgeted = Math.max(task.maxAttempts, task.attempt);
+    return Math.max(windowSize, (Math.floor(usedOrBudgeted / windowSize) + 1) * windowSize);
+}
+export function tryTransitionTaskEvent(task, event, context = {}) {
+    return dispatchTaskLifecycleSync(task, event, context);
+}
+export async function transitionTaskEvent(task, event, context = {}, executeEffect, persist) {
+    const from = task.state;
+    const decision = await dispatchTaskLifecycle(task, event, context, executeEffect, persist);
+    if (!decision.accepted || !decision.target)
+        throw new Error(decision.reason === 'ambiguous'
+            ? `Ambiguous workflow transition from ${from} on ${event}`
+            : `No enabled workflow transition from ${from} on ${event}`);
+    observability().record({
+        stage: 'transition',
+        event,
+        outcome: 'succeeded',
+        message: `Task ${task.id} ${from} -> ${decision.target}`,
+        correlation: { jobId: task.jobId, taskId: task.id, executionId: task.executionId ?? undefined },
+        transition: { graph: 'task-lifecycle', from, to: decision.target, actions: decision.actions },
+    });
+    return decision;
+}
+export async function transitionJobEvent(job, event, context = {}, executeEffect, persist) {
+    const from = job.state;
+    const decision = await dispatchJobLifecycle(job, event, context, executeEffect, persist);
+    if (!decision.accepted || !decision.target)
+        throw new Error(decision.reason === 'ambiguous'
+            ? `Ambiguous workflow transition from ${from} on ${event}`
+            : `No enabled workflow transition from ${from} on ${event}`);
+    observability().record({
+        stage: 'transition',
+        event,
+        outcome: 'succeeded',
+        message: `Job ${job.id} ${from} -> ${decision.target}`,
+        correlation: { repository: job.repository, prNumber: job.prNumber, jobId: job.id },
+        transition: { graph: 'job-lifecycle', from, to: decision.target, actions: decision.actions },
+    });
+    return decision;
+}

package/dist/troubleshooter-fallback.js

@@ -1,4 +1,4 @@
-import { tryTransitionTaskEvent } from './scheduler.js';
+import { tryTransitionTaskEvent } from './task-transitions.js';
 import { requestTroubleshooterEscalation } from './task-recovery.js';
 const MARKER = '[Relay execution fallback attempted]';
 const RUNTIME_FAILURE = /worker_process_failed|worker_start_timeout|terminal_event_timeout|model.*not supported|unsupported.model|delivery|process.exited|provider/i;

package/dist/troubleshooter.js

@@ -28,10 +28,7 @@ Inspect event order, type/status, source, data/phase, duplicate events, missing
 
 Follow the selected Troubleshooter agent contract. Diagnose root cause from durable task state, append-only comments, task-scoped event history, and relevant runtime logs before retry. The final task.error string alone is never sufficient. Independently verify every human response against evidence from the exact original failing execution context; a response or historical resolution condition alone never proves recovery. Classify evidence as model/provider/runtime, worker/tool/infrastructure, semantic task failure, or timeout/unknown. Select one graph-enabled resolution path: exact_original_retry, same_job_dependency, blocker_job_dependency, escalation_gate, or cancel_supersede. For confirmed adapter/model/provider failure, include --failure-kind, --reason, --evidence and --reroute in task recover; use --exclude-current-route only if the exact failed route should not be selected again. For semantic task failure use --failure-kind task_failure without rerouting. For uncertain failures use --failure-kind unknown and preserve routing unless evidence justifies rerouting. Request the existing agents-relay task recover or agents-relay escalation operation; submission alone is not recovery. Reload authoritative SQLite state and verify the requested resolution and exact-original retry postconditions before reporting success. Bound self-healing retries to the durable Task retry budget. For a shared worker/runtime/tool defect, use its owning repository's P0/self-job workflow and verify the durable fix before requesting recovery. Never use ordinary task retry from a Troubleshooter because manual retry intentionally supersedes active recovery. Do not manually choose a provider/model or create a replacement task. If diagnosis suggests a genuine human/external blocker, invoke the escalation command; do not publish task.blocked or implement a workflow branch procedurally. The canonical escalation graph invokes Neo escalation and owns the resolved/failed/needs_user branch; Relay applies the selected outcome. Retry this exact original task only after the blocker is removed, reconcile the original job, and verify durable progress.`;
 }
-function belongsToCurrentRun(job, task) {
-    const slot = job.schedule?.currentRunSlot;
-    return !slot || task.createdAt >= slot;
-}
+function belongsToCurrentRun(_job, _task) { return true; }
 const ACTIVE_RECOVERY_STATES = new Set(['DRAFT', 'QUEUED', 'RUNNING', 'BLOCKED']);
 function recoveryTargetsTask(recovery, original) {
     if (recovery.agentName !== 'troubleshooter')

package/dist/types.js

@@ -4,8 +4,7 @@ export function storySizeTimeoutMs(size) { return STORY_SIZE_TIMEOUT_MS[size]; }
 export function taskOverallTimeoutMs(size, reasoning) { return storySizeTimeoutMs(size) * (reasoning?.toLowerCase() === 'high' ? 2 : 1); }
 export function chatGptStartAckTimeoutMs(overallTimeoutMs) { return Math.min(600000, Math.max(120000, Math.floor(overallTimeoutMs / 3))); }
 /** Normalize snapshots written before UNBLOCKED was removed from the lifecycle graph. */
-export function normalizeLegacyTaskLifecycle(task, executionMode) {
-    void executionMode;
+export function normalizeLegacyTaskLifecycle(task) {
     const legacy = task;
     if (legacy.state === 'UNBLOCKED') {
         legacy.state = task.agentName === 'troubleshooter' ? 'QUEUED' : 'FAILED';

package/dist/unblock.js

@@ -1,5 +1,5 @@
 import { applyTaskUnblockRetrySnapshot } from './task-actions.js';
-import { tryTransitionTaskEvent } from './scheduler.js';
+import { tryTransitionTaskEvent } from './task-transitions.js';
 import { dispatchAuthoritativeUnblock } from './workflow/authoritative-unblock-v2.js';
 import { hasPendingTroubleshooterEscalation } from './task-recovery.js';
 export function isEffectivelyBlocked(task) { return task.kind !== 'planner' && task.agentName === 'troubleshooter' && task.state === 'BLOCKED'; }
@@ -31,7 +31,7 @@ function unblockFacts(job, tasks, currentHeadSha, reason) {
     return [...new Set(facts)];
 }
 export function unconsumedUnblockTrigger(job) {
-    const consumed = new Set((job.plans ?? []).filter(plan => plan.status === 'SUCCEEDED').flatMap(plan => plan.trigger.source === 'unblock' ? plan.trigger.taskIds ?? [] : []));
+    const consumed = new Set((job.plans ?? []).filter(plan => plan.status === 'SUCCEEDED').flatMap(plan => plan.trigger?.source === 'unblock' ? plan.trigger.taskIds ?? [] : []));
     const tasks = job.tasks.filter(task => task.agentName !== 'troubleshooter' && task.unblock && !consumed.has(task.id) && ['DRAFT', 'QUEUED'].includes(task.state));
     if (tasks.length === 0) {
         const legacy = job.changeCycle;
@@ -56,12 +56,8 @@ export function unblockNeedsNewPlan(job) {
     if (!pending)
         return false;
     const latest = job.plans?.at(-1);
-    return !(latest?.status === 'FAILED' && latest.trigger.source === 'unblock'
-        && latest.trigger.taskIds?.some(id => pending.taskIds?.includes(id)));
-}
-export async function unblockAutonomousTasks(options) {
-    void options;
-    throw new Error('Ordinary Tasks cannot be authoritatively unblocked; only a blocked Troubleshooter can resume');
+    return !(latest?.status === 'FAILED' && latest.trigger?.source === 'unblock'
+        && latest.trigger?.taskIds?.some(id => pending.taskIds?.includes(id)));
 }
 export async function unblockTask(options) {
     if (!isEffectivelyBlocked(options.task))
@@ -83,7 +79,7 @@ export async function unblockTask(options) {
                 const task = current.tasks.find(item => item.id === options.task.id);
                 if (!task || !isEffectivelyBlocked(task))
                     throw new Error(`Task ${options.task.id} changed before authoritative unblock`);
-                if (!tryTransitionTaskEvent(task, 'task.unblocked', { autonomousJob: false }).accepted)
+                if (!tryTransitionTaskEvent(task, 'task.unblocked', {}).accepted)
                     throw new Error(`Task ${task.id} cannot be authoritatively unblocked`);
                 const baseline = baselineFor(task);
                 task.blockedBaseline = baseline;

package/dist/worker-rejection.js

@@ -1,4 +1,4 @@
-/** Classify genuine worker-process rejection text, regardless of E2E mode. */
+/** Classify genuine worker-process rejection text. */
 export function classifyWorkerRejection(message) {
     if (/rate[_ .-]?limit[_ .-]?exceeded|usage limit reached|quota[_ .-]?exceeded|insufficient[_ .-]?quota/i.test(message))
         return 'rate_limit_exceeded';

package/dist/workflow/authoritative-conditions.js

@@ -1,4 +1,4 @@
-import { completionGateSatisfied } from '../scheduler.js';
+import { completionGateSatisfied } from '../task-transitions.js';
 export function verifyAuthoritativeCondition(db, jobId, predicate, taskId, executionId) {
     if (!jobId)
         throw new Error('job ID required');

package/dist/workflow/blocker-resolution-v2.js

@@ -5,13 +5,12 @@ const source = readFileSync(new URL('../../workflow/blocker-resolution.mmd', imp
 const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
 export const blockerResolutionV2 = new GraphRuntime(source, {
     states: new Set([
-        'waiting', 'check_target', 'check_autonomous', 'check_effective', 'check_already_unblocked',
+        'waiting', 'check_target', 'check_effective', 'check_already_unblocked',
         'check_draft', 'check_blocked', 'check_failed', 'check_unblocked', 'wait', 'obsolete', 'resumed',
     ]),
     guards: {
         resolutionAllowed: boolGuard('resolutionAllowed'),
         targetMatches: boolGuard('targetMatches'),
-        autonomousJob: boolGuard('autonomousJob'),
         effectivelyBlocked: boolGuard('effectivelyBlocked'),
         alreadyUnblocked: boolGuard('alreadyUnblocked'),
         isDraft: boolGuard('isDraft'),
@@ -20,8 +19,7 @@ export const blockerResolutionV2 = new GraphRuntime(source, {
         isUnblocked: boolGuard('isUnblocked'),
     },
     actions: Object.fromEntries([
-        'blocker.autonomousUnblock', 'blocker.acceptExistingUnblock', 'blocker.releaseDraft',
-        'blocker.unblockTask', 'blocker.retryFailed', 'blocker.retryUnblocked',
+        'blocker.releaseDraft',
     ].map(id => [id, { id }])),
     events: { 'blocker.resolved': { id: 'blocker.resolved' } },
 });

package/dist/workflow/contracts.js

@@ -56,7 +56,6 @@ export const WORKFLOW_FACT_NAMES = [
     'retryAvailable',
     'reviewUnblocked',
     'initialPlan',
-    'scheduledRun',
     'hasUnblock',
     'manualPlan',
     'reviewDisabled',

package/dist/workflow/definitions-v2.js

@@ -5,7 +5,7 @@ import { WORKFLOW_EFFECT_NAMES, WORKFLOW_EVENT_NAMES, WORKFLOW_MUTATION_NAMES, }
 const TASK_STATES = ['DRAFT', 'QUEUED', 'RUNNING', 'BLOCKED', 'SUCCEEDED', 'FAILED', 'CANCELLED'];
 const JOB_STATES = ['DRAFT', 'ACTIVE', 'COMPLETED', 'CANCELLED'];
 const conditionRegistry = new ConditionRegistry([
-    ...new Set(['dependenciesSatisfied', 'dependenciesUnsatisfied', 'runnable', 'dispatchable', 'recoverableExecution', 'troubleshooterRecovery', 'troubleshooterTask', 'awaitingInteractiveDecision', 'retryAvailable', 'autonomousJob', 'notMerged', 'autoMerge', 'prOpen', 'reviewDisabled', 'implementationComplete', 'headAvailable', 'mergeCapable', 'localCompletionAllowed', 'localMergeReady'])
+    ...new Set(['dependenciesSatisfied', 'dependenciesUnsatisfied', 'runnable', 'dispatchable', 'recoverableExecution', 'troubleshooterRecovery', 'troubleshooterTask', 'awaitingInteractiveDecision', 'retryAvailable', 'notMerged', 'autoMerge', 'prOpen', 'reviewDisabled', 'implementationComplete', 'headAvailable', 'mergeCapable', 'localCompletionAllowed', 'localMergeReady'])
 ].map(booleanCondition));
 const boolGuard = (name) => conditionRegistry.guard(name);
 export const lifecycleConditions = conditionRegistry;
@@ -34,7 +34,6 @@ export const taskLifecycleV2 = load('task-lifecycle', TASK_STATES, {
     troubleshooterTask: boolGuard('troubleshooterTask'),
     awaitingInteractiveDecision: facts => facts.durableFacts.awaitingInteractiveDecision === true,
     retryAvailable: boolGuard('retryAvailable'),
-    autonomousJob: boolGuard('autonomousJob'),
 });
 export const jobLifecycleV2 = load('job-lifecycle', JOB_STATES, {
     notMerged: boolGuard('notMerged'),
@@ -46,15 +45,13 @@ export const jobLifecycleV2 = load('job-lifecycle', JOB_STATES, {
     mergeCapable: boolGuard('mergeCapable'),
     localCompletionAllowed: (facts) => {
         const values = facts.durableFacts;
-        return values.jobActive === true && values.autoMergeEnabled === true && values.schedulePresent !== true
-            && values.implementationComplete === true && values.completionGateSatisfied === true
+        return values.jobActive === true && values.autoMergeEnabled === true && values.implementationComplete === true && values.completionGateSatisfied === true
             && values.reviewSatisfied === true
             && (values.localMergeRequired !== true || values.localMergeSucceeded === true);
     },
     localMergeReady: (facts) => {
         const values = facts.durableFacts;
-        return values.jobActive === true && values.autoMergeEnabled === true && values.schedulePresent !== true
-            && values.implementationComplete === true && values.completionGateSatisfied === true
+        return values.jobActive === true && values.autoMergeEnabled === true && values.implementationComplete === true && values.completionGateSatisfied === true
             && values.reviewSatisfied === true && values.localMergePresent === true
             && values.reviewHeadCurrent === true && values.mergeAttemptReady === true;
     },

package/dist/workflow/durable-transition.js

@@ -1,4 +1,4 @@
-import { tryTransitionTaskEvent } from '../scheduler.js';
+import { tryTransitionTaskEvent } from '../task-transitions.js';
 import { observability } from '../observability.js';
 /**
  * Runtime primitive for applying one canonical Task-graph event to fresh durable state.

package/dist/workflow/force-restate-validation-v2.js

@@ -3,11 +3,12 @@ import { GraphRuntime } from './graph-v2.js';
 import { dispatchWorkflowGraphSync } from './dispatcher.js';
 const source = readFileSync(new URL('../../workflow/force-restate-validation.mmd', import.meta.url), 'utf8');
 export const forceRestateValidationV2 = new GraphRuntime(source, {
-    states: new Set(['idle', 'check_history_mode', 'check_history', 'check_normal_history', 'check_forward', 'rejected', 'committed']),
+    states: new Set(['idle', 'check_history_mode', 'check_history', 'check_normal_history', 'check_satisfied', 'check_forward', 'rejected', 'committed']),
     guards: {
         forceRestateRequested: facts => facts.durableFacts.forceRestateRequested === true,
         historyConsistencyValid: facts => facts.durableFacts.historyConsistencyValid === true,
         normalHistoryMutationAbsent: facts => facts.durableFacts.normalHistoryMutationAbsent === true,
+        objectiveSatisfied: facts => facts.durableFacts.objectiveSatisfied === true,
         forwardConvergenceValid: facts => facts.durableFacts.forwardConvergenceValid === true,
     },
     actions: {

package/dist/workflow/orchestrator-rescue.js

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { dispatchWorkflowGraphSync } from './dispatcher.js';
 import { GraphRuntime } from './graph-v2.js';
-import { tryTransitionTaskEvent } from '../scheduler.js';
+import { tryTransitionTaskEvent } from '../task-transitions.js';
 import { taskOverallTimeoutMs } from '../types.js';
 export const STALE_ORCHESTRATOR_TASK_MS = 30 * 60 * 1000;
 const source = readFileSync(new URL('../../workflow/orchestrator-rescue.mmd', import.meta.url), 'utf8');

package/dist/workflow/planner-orchestration-v2.js

@@ -10,7 +10,6 @@ export const plannerOrchestrationV2 = new GraphRuntime(source, {
         'check_blocked', 'check_work', 'check_materialized', 'check_objective', 'wait', 'recovered', 'created',
     ]),
     guards: {
-        autonomousJob: boolGuard('autonomousJob'),
         legacyPlanningPending: boolGuard('legacyPlanningPending'),
         recoverablePendingPlan: boolGuard('recoverablePendingPlan'),
         terminalPlanFailure: boolGuard('terminalPlanFailure'),
@@ -38,9 +37,8 @@ export function decidePlannerOrchestration(facts) {
     return dispatchWorkflowGraphSync(plannerOrchestrationV2, { initialState: 'idle', input: { transport: 'event', id: 'planner.reconcile', payload: {} }, durableFacts: facts, graphName: 'planner-orchestration', isTransientState: state => state.startsWith('check_'), maxSteps: 14 });
 }
 export function plannerOrchestrationFacts(job, recoverablePendingPlan) {
-    const slot = job.schedule?.currentRunSlot ? Date.parse(job.schedule.currentRunSlot) : Number.NaN;
-    const scopedTasks = Number.isFinite(slot) ? job.tasks.filter(task => Date.parse(task.createdAt) >= slot) : job.tasks;
-    const scopedPlans = (job.plans ?? []).filter(plan => !Number.isFinite(slot) || Date.parse(plan.createdAt) >= slot)
+    const scopedTasks = job.tasks;
+    const scopedPlans = (job.plans ?? [])
         .sort((a, b) => a.round - b.round || a.createdAt.localeCompare(b.createdAt));
     const latestPlan = scopedPlans.at(-1);
     const failedPlan = latestPlan?.status === 'FAILED' ? latestPlan : null;
@@ -56,7 +54,6 @@ export function plannerOrchestrationFacts(job, recoverablePendingPlan) {
     const latestId = latestPlan?.id ?? legacyLatest?.id;
     const latestObjective = latestPlan?.objectiveStatus ?? legacyLatest?.plannerResult?.objective_status;
     return {
-        autonomousJob: job.executionMode === 'autonomous' || latestPlan?.forceRestate === true,
         legacyPlanningPending: job.initialPlanning?.status === 'pending',
         recoverablePendingPlan,
         terminalPlanFailure: Boolean(failedPlan && (!failedPlan.manualPlanning || failedPlan.forceRestate) && failedPlan.trigger.source !== 'unblock'),

package/dist/workflow/planner-trigger-v2.js

@@ -4,11 +4,10 @@ import { dispatchWorkflowGraphSync } from './dispatcher.js';
 const source = readFileSync(new URL('../../workflow/planner-trigger.mmd', import.meta.url), 'utf8');
 const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
 export const plannerTriggerV2 = new GraphRuntime(source, {
-    states: new Set(['idle', 'check_unblock', 'check_schedule', 'check_initial', 'manual', 'unblock', 'schedule', 'initial', 'continuation']),
+    states: new Set(['idle', 'check_unblock', 'check_initial', 'manual', 'unblock', 'initial', 'continuation']),
     guards: {
         manualPlan: boolGuard('manualPlan'),
         hasUnblock: boolGuard('hasUnblock'),
-        scheduledRun: boolGuard('scheduledRun'),
         initialPlan: boolGuard('initialPlan'),
     },
     actions: {},

package/dist/workflow/review-v2.js

@@ -6,7 +6,6 @@ const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
 export const reviewLifecycleV2 = new GraphRuntime(source, {
     states: new Set(['NONE', 'PENDING', 'STARTED', 'APPROVED', 'CHANGES_REQUIRED', 'BLOCKED', 'STALE']),
     guards: {
-        unscheduled: boolGuard('unscheduled'),
         reviewEnabled: boolGuard('reviewEnabled'),
         prOpen: boolGuard('prOpen'),
         jobActive: boolGuard('jobActive'),

package/dist/workflow/task-reconcile.js

@@ -20,15 +20,9 @@ export function detectCycles(tasks) {
     for (const task of tasks)
         visit(task.id);
 }
-function scheduledCycleTasks(job) {
-    const slot = job.schedule?.currentRunSlot ? Date.parse(job.schedule.currentRunSlot) : Number.NaN;
-    if (!Number.isFinite(slot))
-        return job.tasks;
-    return job.tasks.filter(task => Date.parse(task.createdAt) >= slot);
-}
 export function reconcileTaskDependencies(job) {
     detectCycles(job.tasks);
-    const scopedTasks = scheduledCycleTasks(job);
+    const scopedTasks = job.tasks;
     const tasks = new Map(job.tasks.map(task => [task.id, task]));
     for (const task of scopedTasks) {
         if (task.kind === 'planner')

package/dist/workflow-effect-failures.js

@@ -1,4 +1,4 @@
-import { transitionJobEvent, transitionTaskEvent } from './scheduler.js';
+import { transitionJobEvent, transitionTaskEvent } from './task-transitions.js';
 import { workflowEffectFailureEvent } from './workflow/contracts.js';
 import { eventFor } from './events.js';
 export async function applyJobEffectOutcomes(store, emit, job, outcomes) {

package/dist/workspace.js

@@ -191,7 +191,7 @@ export function managedLocalJobWorktreePath(repository, jobId, workspaceRoot = d
 }
 /** Only code artifacts need an isolated Git source branch and worktree. */
 export function jobRequiresManagedWorktree(job) {
-    return !(job.prNumber > 0) && !job.schedule && (Boolean(job.localMerge?.sourceRef) || job.tasks.some(task => task.output?.kind === 'task_pr'));
+    return !(job.prNumber > 0) && (Boolean(job.localMerge?.sourceRef) || job.tasks.some(task => task.output?.kind === 'task_pr'));
 }
 /** Bind an ordinary SQLite Job to one deterministic local work branch.
  * The target is always main, and branch creation never switches the user's checkout.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.169",
+  "version": "2.0.171",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "repository": {
     "type": "git",
@@ -17,12 +17,11 @@
     "test:chatgpt-temp-quality": "AGENTS_RELAY_RUN_CHATGPT_TEMP_QUALITY=1 sh -c \"npm run build && node test/quality/run-temporary-chat.mjs\"",
     "dev": "tsx src/cli.ts",
     "test:publish": "npm run build && node --import ./test/test-store-env.mjs --test --test-concurrency=1 --test-force-exit test/*.test.js",
-    "test:fast": "npm run build && node --import ./test/test-store-env.mjs --test --test-concurrency=2 test/workflow-lifecycle.test.js test/workflow-v2-lifecycle-parity.test.js test/workflow-effects.test.js test/relay-store.test.js test/local-authority.test.js test/local-jobid-routing.test.js test/local-sqlite-jobid.test.js test/no-github.test.js test/scheduled-jobs.test.js test/reconcile-coordinator.test.js test/service-publication.test.js test/github-webhook.test.js",
+    "test:fast": "npm run build && node --import ./test/test-store-env.mjs --test --test-concurrency=2 test/workflow-lifecycle.test.js test/workflow-v2-lifecycle-parity.test.js test/workflow-effects.test.js test/relay-store.test.js test/local-authority.test.js test/local-jobid-routing.test.js test/local-sqlite-jobid.test.js test/no-github.test.js test/reconcile-coordinator.test.js test/service-publication.test.js test/github-webhook.test.js",
     "test:full": "npm run build && node --import ./test/test-store-env.mjs --test --test-concurrency=1 test/*.test.js && npm run test:verification:l3",
     "test:verification:l1": "npm run build && node --test test/verification/harness.test.mjs test/verification/contract.test.mjs test/verification/graph-inventory.test.mjs test/verification/dashboard-drilldown.test.mjs test/verification/evidence-matrix.test.mjs test/verification/task-resolution-classification.test.mjs test/verification/planner-contract.test.mjs test/verification/force-restate-validation.test.mjs test/planner-child-recovery.test.js",
-    "test:verification:l3": "npm run build && node --test --test-concurrency=1 test/verification/harness.test.mjs test/verification/l3-sqlite.test.mjs test/verification/l3-ingress.test.mjs test/verification/l3-replay.test.mjs test/verification/objective-authority.test.mjs test/verification/l3-convergence.test.mjs test/verification/l3-review-convergence.test.mjs test/verification/l3-human-escalation.test.mjs test/verification/l3-escalation-notifier.test.mjs test/verification/l3-unknown-effect.test.mjs test/verification/l3-cli-actions.test.mjs test/verification/l3-planner-round.test.mjs test/verification/l3-planner-cli.test.mjs test/verification/l3-task-resolution.test.mjs test/verification/l3-plan-apply-convergence.test.mjs test/verification/full-recovery-gates.test.mjs test/verification/production-wiring.test.mjs test/verification/l3-full-path.test.mjs test/verification/l3-projection-recovery.test.mjs test/verification/l3-daemon-startup-recovery.test.mjs",
+    "test:verification:l3": "npm run build && node --test --test-concurrency=1 test/verification/harness.test.mjs test/local-sqlite-jobid.test.js test/verification/l3-sqlite.test.mjs test/verification/l3-ingress.test.mjs test/verification/l3-replay.test.mjs test/verification/objective-authority.test.mjs test/verification/l3-convergence.test.mjs test/verification/l3-review-convergence.test.mjs test/verification/l3-human-escalation.test.mjs test/verification/l3-escalation-notifier.test.mjs test/verification/l3-unknown-effect.test.mjs test/verification/l3-cli-actions.test.mjs test/verification/l3-planner-round.test.mjs test/verification/l3-planner-cli.test.mjs test/verification/l3-task-resolution.test.mjs test/verification/l3-plan-apply-convergence.test.mjs test/verification/full-recovery-gates.test.mjs test/verification/production-wiring.test.mjs test/verification/l3-full-path.test.mjs test/verification/l3-projection-recovery.test.mjs test/verification/l3-daemon-startup-recovery.test.mjs",
     "test:verification": "npm run test:verification:l1 && npm run test:verification:l2 && npm run test:verification:l3 && npm run test:verification:cross-a && node --test test/workflow-production-outbox.test.js && npm run test:verification:matrix",
-    "e2e": "node e2e/runner/run.mjs",
     "test:verification:cross-a": "npm run build && RELAY_A_DIST=$PWD/dist node --test test/verification/action-ledger-cross-branch.test.mjs test/verification/outbox-cross-a.test.mjs",
     "test:verification:matrix": "node test/verification/recovery-report.mjs /tmp/agents-relay-job481-evidence",
     "test:verification:l2": "npm run build && node --test test/verification/l2/*.test.mjs",