agents-relay 2.0.156 → 2.0.157

package/dist/blockers.js

@@ -1,5 +1,5 @@
-import { applyTaskReleaseAction, applyTaskUnblockRetryAction, dispatchTaskAction } from './task-actions.js';
-import { isEffectivelyBlocked, unblockAutonomousTasks, unblockTask } from './unblock.js';
+import { applyTaskReleaseAction } from './task-actions.js';
+import { isEffectivelyBlocked } from './unblock.js';
 import { dispatchBlockerResolution } from './workflow/blocker-resolution-v2.js';
 import { dispatchTaskResolutionSync, materializeResolution } from './workflow/task-resolution.js';
 function dependentKey(value) {
@@ -99,47 +99,25 @@ export async function resolveBlockerDependencies(options) {
             loadError = error instanceof Error ? error.message : String(error);
         }
         const targetMatches = !!task && ['DRAFT', 'FAILED', 'BLOCKED', 'QUEUED'].includes(task.state) && task.attempt === relation.blockedAttempt;
-        let note = 'dependent task requeued';
+        let note = 'dependent task released from dependency wait';
         const decision = await dispatchBlockerResolution({
             resolutionAllowed: !(mode === 'verified' && options.resolution !== 'verified'),
             targetMatches,
             autonomousJob: targetJob?.executionMode === 'autonomous',
             effectivelyBlocked: !!task && isEffectivelyBlocked(task),
             alreadyUnblocked: Boolean(task?.unblock && ['DRAFT', 'QUEUED'].includes(task.state)),
-            isDraft: task?.state === 'DRAFT', isBlocked: task?.state === 'BLOCKED',
+            isDraft: task?.state === 'DRAFT', isBlocked: Boolean(task && isEffectivelyBlocked(task)),
             isFailed: task?.state === 'FAILED', isUnblocked: Boolean(task?.unblock && ['DRAFT', 'QUEUED'].includes(task.state)),
         }, async (actionId) => {
             if (!targetJob || !task)
                 throw new Error('Blocker graph requested action without a matching dependent task');
-            if (actionId === 'blocker.autonomousUnblock') {
-                await unblockAutonomousTasks({ store, job: targetJob, tasks: [task], trigger: { source: 'blocker_job', reason: 'Blocker Job ' + blocker.id + ' resolved (' + options.resolution + ')', blockerJobId: blocker.id, resolution: options.resolution }, now });
-                unblocked.push({ repository: relation.repository, prNumber: relation.prNumber, jobId: relation.jobId, taskId: relation.taskId });
-                note = 'dependent task unblocked for replanning';
-            }
-            else if (actionId === 'blocker.acceptExistingUnblock')
-                note = 'dependent Job already unblocked for replanning';
-            else if (actionId === 'blocker.releaseDraft') {
+            if (actionId === 'blocker.releaseDraft') {
                 await applyTaskReleaseAction(task);
                 task.error = null;
                 task.updatedAt = now;
                 delete task.blockedBy;
                 await store.saveTask(task);
             }
-            else if (actionId === 'blocker.unblockTask') {
-                await unblockTask({ store, job: targetJob, task, trigger: { source: 'blocker_job', reason: 'Blocker Job ' + blocker.id + ' resolved (' + options.resolution + ')', blockerJobId: blocker.id, resolution: options.resolution }, now });
-                unblocked.push({ repository: relation.repository, prNumber: relation.prNumber, jobId: relation.jobId, taskId: relation.taskId });
-            }
-            else if (actionId === 'blocker.retryFailed') {
-                const result = await dispatchTaskAction(store, { id: 'task.retry', jobId: targetJob.id, taskId: task.id });
-                delete result.task.blockedBy;
-                result.task.updatedAt = now;
-                await store.saveTask(result.task);
-            }
-            else if (actionId === 'blocker.retryUnblocked') {
-                await applyTaskUnblockRetryAction(task);
-                task.updatedAt = now;
-                await store.saveTask(task);
-            }
             else
                 throw new Error('Unsupported blocker graph action ' + actionId);
             return {};
@@ -160,6 +138,7 @@ export async function resolveBlockerDependencies(options) {
         relation.resolvedAt = now;
         relation.resolution = options.resolution;
         relation.note = note;
+        unblocked.push({ repository: relation.repository, prNumber: relation.prNumber, jobId: relation.jobId, taskId: relation.taskId });
         resumed += 1;
     }
     const remaining = relations.filter(relation => relation.state === 'waiting');

package/dist/chatgpt-platform-fallback.js

@@ -32,7 +32,7 @@ export async function quarantineUnavailableCodexFallback(transitions, emit, jobI
         mutate: (_job, task) => { task.error = `Codex fallback route became unavailable: ${error instanceof Error ? error.message : String(error)}`; },
     });
     if (transition?.decision.accepted)
-        await emit(eventFor(jobId, taskId, transition.task.parentTaskId, 'task.blocked', 'blocked', transition.task.error ?? 'Codex fallback route unavailable', 'user', { reason: transition.task.failureReason, phase: 'fallback-routing' }));
+        await emit(eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? 'Codex fallback route unavailable', 'user', { reason: transition.task.failureReason, phase: 'fallback-routing' }));
 }
 export function persistChatGptPlatformFailure(task, original, executionId, classification, evidence, safeToReroute) {
     const route = original?.routing;

package/dist/cli-help.js

@@ -93,7 +93,7 @@ Example:
     'job merge': `Request an idempotent external pull-request merge; return QUEUED until confirmed, when the Graph Engine completes the Job.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID. The current PR head SHA is pinned into the merge request.`,
-    'job unblock': `Authoritatively unblock the effective BLOCKED work Tasks in one Job.\n\nRequired: --repo OWNER/REPO --pr NUMBER --id JOB_ID --reason TEXT. Autonomous Jobs move blocked work to planner-waiting DRAFT with durable unblock facts; fixed Jobs resume directly as QUEUED with a reset retry budget.`,
+    'job unblock': `Authoritatively unblock BLOCKED Troubleshooter Tasks in one Job.\n\nRequired: --repo OWNER/REPO --pr NUMBER --id JOB_ID --reason TEXT. Each unblocked Troubleshooter is queued as the same Task and must rerun, verify the condition, and issue a fresh resolution before retrying an original failed Task.`,
     'job cancel': `Cancel the durable Job and close its backing pull request.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID. Nonterminal Tasks are cancelled before the PR is closed.`,

package/dist/cli-unblock.js

@@ -1,5 +1,5 @@
 import { arg, publishTaskUnblocked, publishWake, saveLocal, withEventBus } from './cli-support.js';
-import { isEffectivelyBlocked, unblockAutonomousTasks, unblockTask } from './unblock.js';
+import { isEffectivelyBlocked, unblockTask } from './unblock.js';
 import { resumeTroubleshooter } from './task-recovery.js';
 export async function runTaskUnblockCommand(args, store, job, task, localFile) {
     const reason = arg(args, '--reason');
@@ -29,24 +29,13 @@ export async function runJobUnblockCommand(args, store, job) {
     const blocked = job.tasks.filter(isEffectivelyBlocked);
     if (blocked.length === 0)
         throw new Error(`Job ${job.id} has no effective BLOCKED work task`);
-    if (job.executionMode === 'autonomous') {
-        const planTrigger = await unblockAutonomousTasks({ store, job, tasks: blocked, trigger: { source: 'cli', reason } });
-        const refreshed = await store.load(job.id);
-        await withEventBus(args, async (bus) => {
-            for (const task of blocked)
-                await publishTaskUnblocked(bus, refreshed, task.id, reason);
-            await publishWake(bus, refreshed, 'job', `Job ${job.id} unblocked for replanning`);
-        });
-        console.log(JSON.stringify({ jobId: job.id, replanning: true, planTrigger }, null, 2));
-        return;
-    }
     for (const task of blocked)
         await unblockTask({ store, job, task, trigger: { source: 'cli', reason } });
     const refreshed = await store.load(job.id);
     await withEventBus(args, async (bus) => {
         for (const task of blocked)
             await publishTaskUnblocked(bus, refreshed, task.id, reason);
-        await publishWake(bus, refreshed, 'job', `Job ${job.id} unblocked`);
+        await publishWake(bus, refreshed, 'job', `Troubleshooter work in Job ${job.id} resumed`);
     });
-    console.log(JSON.stringify({ jobId: job.id, replanning: false, resumedTasks: blocked.map(task => task.id) }, null, 2));
+    console.log(JSON.stringify({ jobId: job.id, resumedTasks: blocked.map(task => task.id) }, null, 2));
 }

package/dist/dashboard-actions.js

@@ -1,5 +1,5 @@
-import { applyJobGraphTarget, applyTaskGraphTarget } from './workflow/runtime.js';
-import { jobLifecycleV2, taskLifecycleV2 } from './workflow/definitions-v2.js';
+import { applyJobGraphTarget } from './workflow/runtime.js';
+import { jobLifecycleV2 } from './workflow/definitions-v2.js';
 import { dispatchWorkflowTargetOverride } from './workflow/dispatcher.js';
 import { dispatchTaskAction } from './task-actions.js';
 import { applyJobCancelAction } from './job-actions.js';
@@ -45,22 +45,12 @@ export function dashboardTaskSetState(store) {
             throw new Error(`Task ${taskId} not found`);
         if (task.state === state)
             return job;
-        if (task.state === 'BLOCKED' && state !== 'CANCELLED')
-            throw new Error(`Task ${task.id} is BLOCKED; only authoritative unblock may resume it`);
-        const now = new Date().toISOString();
-        const from = task.state;
-        await dispatchWorkflowTargetOverride(taskLifecycleV2, {
-            currentState: from, targetState: state, kind: 'task',
-            persistTransition: (_source, target) => { applyTaskGraphTarget(task, target, now); },
-        });
-        task.manualStateOverrides = [
-            ...(task.manualStateOverrides ?? []),
-            { from, to: state, at: now, actor: 'dashboard-user' },
-        ].slice(-20);
-        task.leaseOwner = null;
-        task.leaseExpiresAt = null;
-        task.executionId = null;
-        await store.saveTask(task);
-        return await store.load(job.id);
+        if (state !== 'CANCELLED')
+            throw new Error('Task lifecycle state is managed by Relay; use retry, cancel, or the Troubleshooter response flow');
+        if (task.state !== 'CANCELLED') {
+            await dispatchTaskAction(store, { id: 'task.cancel', jobId, taskId });
+            return await store.load(job.id);
+        }
+        return job;
     };
 }

package/dist/dashboard-data.js

@@ -0,0 +1,45 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+import { eventsBusHistory } from './events-bus-runtime.js';
+const repositoryPattern = /^([A-Za-z0-9](?:[A-Za-z0-9-]{0,36}[A-Za-z0-9])?)\/([A-Za-z0-9._-]{1,100})$/;
+const workflowDirectory = fileURLToPath(new URL('../workflow/', import.meta.url));
+export async function dashboardWorkflowGraphs() {
+    const names = (await readdir(workflowDirectory)).filter(name => name.endsWith('.mmd')).sort();
+    return Promise.all(names.map(async (name) => {
+        const source = await readFile(join(workflowDirectory, name), 'utf8');
+        const metadata = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(source)?.[1] ?? '';
+        const field = (key) => metadata.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'))?.[1]?.trim() ?? '';
+        return {
+            id: name.replace(/\.mmd$/, ''),
+            name: field('title') || (name === 'main.mmd' ? 'Main / Happy Path' : name.replace(/\.mmd$/, '').split('-').map(part => part.charAt(0).toUpperCase() + part.slice(1)).join(' ')),
+            description: field('description'), path: `workflow/${name}`, source,
+        };
+    }));
+}
+export function githubPrUrl(repository, prNumber) {
+    if (typeof repository !== 'string' || typeof prNumber !== 'number' || !Number.isInteger(prNumber) || prNumber <= 0)
+        return null;
+    const match = repositoryPattern.exec(repository);
+    if (!match)
+        return null;
+    const [, owner, repo] = match;
+    if ([owner, repo].some(segment => segment === '.' || segment === '..'))
+        return null;
+    return `https://github.com/${owner}/${repo}/pull/${prNumber}`;
+}
+export function effectiveGitHubUsage(snapshot, runtime) {
+    const candidates = [snapshot?.resources.core, snapshot?.resources.graphql, snapshot?.resources.search, runtime?.resources.core, runtime?.resources.graphql, runtime?.resources.search]
+        .filter((candidate) => candidate !== undefined && candidate !== null)
+        .filter(candidate => Number.isFinite(candidate.limit) && Number(candidate.limit) > 0 && Number.isFinite(candidate.remaining) && Number.isFinite(candidate.reset));
+    const lowest = candidates.reduce((current, candidate) => !current || Number(candidate.remaining) / Number(candidate.limit) < Number(current.remaining) / Number(current.limit) ? candidate : current, null);
+    return lowest ? { limit: Number(lowest.limit), remaining: Number(lowest.remaining), reset: Number(lowest.reset) } : null;
+}
+export async function eventHistory(jobId, taskId, limit) {
+    try {
+        return await eventsBusHistory(jobId, taskId, limit);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/dashboard.js

@@ -2,67 +2,17 @@ import { inspectWorkflowSymbol } from './dashboard-workflow-inspection.js';
 import { createServer } from 'node:http';
 import { subscribeLocalCommits } from './local-commit-events.js';
 import { handleTroubleshooterQa } from './troubleshooter-qa-api.js';
-import { readFile, readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { readUsageSnapshot } from './usage.js';
 import { deriveJobRuntimeStatus } from './runtime-status.js';
 import { DeliveryDeduper, parseGitHubWebhook, verifyGitHubWebhook } from './github-webhook.js';
 import { loadExecutionRouterRules, saveExecutionRouterRules } from './routing-policy.js';
 import { summarizeRuntime } from './runtime-summary.js';
-import { eventsBusHistory } from './events-bus-runtime.js';
-const GITHUB_REPOSITORY_PATTERN = /^([A-Za-z0-9](?:[A-Za-z0-9-]{0,36}[A-Za-z0-9])?)\/([A-Za-z0-9._-]{1,100})$/;
+import { dashboardWorkflowGraphs, effectiveGitHubUsage, eventHistory } from './dashboard-data.js';
+export { dashboardWorkflowGraphs, githubPrUrl } from './dashboard-data.js';
 const SSE_HEARTBEAT_MS = 15000;
-const WORKFLOW_DIR = fileURLToPath(new URL('../workflow/', import.meta.url));
-export async function dashboardWorkflowGraphs() {
-    const names = (await readdir(WORKFLOW_DIR)).filter(name => name.endsWith('.mmd')).sort();
-    return Promise.all(names.map(async (name) => {
-        const source = await readFile(join(WORKFLOW_DIR, name), 'utf8');
-        const metadata = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(source)?.[1] ?? '';
-        const field = (key) => metadata.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'))?.[1]?.trim() ?? '';
-        return {
-            id: name.replace(/\.mmd$/, ''),
-            name: field('title') || (name === 'main.mmd' ? 'Main / Happy Path' : name.replace(/\.mmd$/, '').split('-').map(part => part.charAt(0).toUpperCase() + part.slice(1)).join(' ')),
-            description: field('description'),
-            path: `workflow/${name}`, source,
-        };
-    }));
-}
-function effectiveGitHubUsage(snapshot, runtime) {
-    const candidates = [snapshot?.resources.core, snapshot?.resources.graphql, snapshot?.resources.search, runtime?.resources.core, runtime?.resources.graphql, runtime?.resources.search]
-        .filter((candidate) => candidate !== undefined && candidate !== null)
-        .filter(candidate => Number.isFinite(candidate.limit) && Number(candidate.limit) > 0 && Number.isFinite(candidate.remaining) && Number.isFinite(candidate.reset));
-    const lowest = candidates.reduce((current, candidate) => !current || Number(candidate.remaining) / Number(candidate.limit) < Number(current.remaining) / Number(current.limit) ? candidate : current, null);
-    return lowest ? { limit: Number(lowest.limit), remaining: Number(lowest.remaining), reset: Number(lowest.reset) } : null;
-}
-function isPositiveInteger(candidate) {
-    return typeof candidate === 'number' && Number.isInteger(candidate) && candidate > 0;
-}
 function isTaskId(candidate) {
     return candidate.length > 0;
 }
-function isSafeRepositorySegment(segment) {
-    return segment !== '.' && segment !== '..';
-}
-export function githubPrUrl(repository, prNumber) {
-    if (typeof repository !== 'string' || !isPositiveInteger(prNumber))
-        return null;
-    const match = GITHUB_REPOSITORY_PATTERN.exec(repository);
-    if (!match)
-        return null;
-    const [, owner, repo] = match;
-    if (!isSafeRepositorySegment(owner) || !isSafeRepositorySegment(repo))
-        return null;
-    return `https://github.com/${owner}/${repo}/pull/${prNumber}`;
-}
-async function eventHistory(jobId, taskId, limit) {
-    try {
-        return await eventsBusHistory(jobId, taskId, limit);
-    }
-    catch {
-        return [];
-    }
-}
 export { dashboardHtml, dashboardVersion, dashboardSourceRevision } from './dashboard-html.js';
 import { dashboardHtml, dashboardVersion } from './dashboard-html.js';
 export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobId, usageRegistry, overviewProvider, webhook, statusProvider, githubUsageProvider, exactJobProvider, actions, routerTestProvider, decisionAuditProvider) {

package/dist/host-invocation-store.js

@@ -51,8 +51,8 @@ export function recordHostInvocationDecision(db, delivery, fingerprint, writeSna
         const job = snapshot?.json ? JSON.parse(snapshot.json) : null;
         const task = job?.tasks.find(item => item.id === delivery.taskId);
         const invocation = task?.interactiveInvocation;
-        if (!job || !task || !invocation || !(['RUNNING', 'BLOCKED'].includes(task.state)) || invocation.executionId !== delivery.executionId ||
-            (task.executionId !== delivery.executionId && task.state !== 'BLOCKED') ||
+        if (!job || !task || !invocation || !(['RUNNING', 'DRAFT'].includes(task.state)) || invocation.executionId !== delivery.executionId ||
+            (task.executionId !== delivery.executionId && task.state !== 'DRAFT') ||
             invocation.status !== 'awaiting_decision' || invocation.invocationId !== delivery.invocationId || invocation.revision !== delivery.revision) {
             recordHostInvocationEvent(db, delivery, 'stale', fingerprint);
             db.exec('COMMIT');

package/dist/interactive-invocation.js

@@ -167,7 +167,7 @@ export class HostInteractiveInvocationCoordinator {
         const job = await this.options.store.loadJob(delivery.jobId);
         const task = job?.tasks.find((item) => item.id === delivery.taskId);
         if (!job || !task || task.interactiveInvocation?.executionId !== delivery.executionId ||
-            (task.executionId !== delivery.executionId && task.state !== 'BLOCKED')) {
+            (task.executionId !== delivery.executionId && task.state !== 'DRAFT')) {
             await this.options.store.recordHostInvocationEvent?.(delivery, 'stale', interactiveDecisionFingerprint(delivery));
             return { outcome: 'stale', reason: 'execution_not_bound' };
         }

package/dist/interactive-resume.js

@@ -8,13 +8,13 @@ export async function resumeInteractiveTask(store, jobId, taskId, invocationId,
     await store.mutateJob(jobId, job => {
         const task = job.tasks.find(item => item.id === taskId);
         const invocation = task?.interactiveInvocation;
-        if (!task || task.state !== 'BLOCKED' || !invocation ||
+        if (!task || task.state !== 'DRAFT' || !invocation ||
             invocation.invocationId !== invocationId || invocation.revision !== revision ||
             invocation.status !== decision || !invocation.decidedAt)
             return job;
-        // Both state transitions and retry eligibility are owned by task-lifecycle.mmd.
-        if (!tryTransitionTaskEvent(task, 'task.unblocked', { autonomousJob: false }).accepted) {
-            throw new Error('Interactive Task unblock rejected by canonical lifecycle Graph');
+        // Accepted interactive decisions release the same waiting Task from DRAFT.
+        if (!tryTransitionTaskEvent(task, 'release').accepted) {
+            throw new Error('Interactive Task release rejected by canonical lifecycle Graph');
         }
         applyTaskUnblockRetrySnapshot(task);
         task.error = null;
@@ -30,7 +30,7 @@ export async function recoverInteractiveDecisions(store, jobId) {
     const job = await store.load(jobId);
     let recovered = false;
     for (const task of job.tasks) {
-        if (task.state !== 'BLOCKED' || !task.interactiveInvocation?.decidedAt)
+        if (task.state !== 'DRAFT' || !task.interactiveInvocation?.decidedAt)
             continue;
         const invocation = task.interactiveInvocation;
         if (invocation.status === 'awaiting_decision' || !await shouldRecoverInteractiveDecision(invocation.status))

package/dist/legacy-blocked-task-migration.js

@@ -0,0 +1,14 @@
+import { normalizeLegacyTaskLifecycle } from './types.js';
+/** Move pre-contract ordinary BLOCKED snapshots to FAILED without touching the
+ * independent append-only event history. Unknown execution evidence is kept. */
+export function migrateLegacyBlockedTasks(db) {
+    const rows = db.prepare('SELECT job_id,json FROM job_snapshot').all();
+    const update = db.prepare('UPDATE job_snapshot SET json=? WHERE job_id=?');
+    for (const row of rows) {
+        const job = JSON.parse(row.json);
+        const before = JSON.stringify(job.tasks);
+        job.tasks = job.tasks.map(task => normalizeLegacyTaskLifecycle(task, job.executionMode));
+        if (JSON.stringify(job.tasks) !== before)
+            update.run(JSON.stringify(job), row.job_id);
+    }
+}

package/dist/legacy-orchestrator-repair.js

@@ -6,7 +6,7 @@ export async function repairLegacyOrchestrators(jobId, now, ports) {
     const { store } = ports;
     const repairOne = async (taskId) => {
         if (store.mutateJob) {
-            let outcome = { repaired: false, externallyCompleted: false, blocked: false, ageMs: 0 };
+            let outcome = { repaired: false, externallyCompleted: false, failed: false, ageMs: 0 };
             return await store.mutateJob(jobId, current => {
                 const task = current.tasks.find(item => item.id === taskId);
                 if (!task)
@@ -40,12 +40,12 @@ export async function repairLegacyOrchestrators(jobId, now, ports) {
         const job = await store.load(jobId);
         const task = job.tasks.find(item => item.id === stale.id);
         const type = repair.externallyCompleted ? 'task.external_completion_applied'
-            : repair.blocked ? 'task.orchestrator_quarantined' : 'task.orchestrator_rescued';
-        const status = repair.externallyCompleted ? 'succeeded' : repair.blocked ? 'blocked' : 'queued';
+            : repair.failed ? 'task.orchestrator_quarantined' : 'task.orchestrator_rescued';
+        const status = repair.externallyCompleted ? 'succeeded' : repair.failed ? 'failed' : 'queued';
         await ports.emit(eventFor(job.id, task.id, task.parentTaskId, type, status, repair.externallyCompleted
             ? `Applied durable external completion for legacy orchestrator task ${task.id}`
-            : repair.blocked
-                ? `Quarantined legacy RUNNING orchestrator task ${task.id}; external outcome must be verified before replacement work`
-                : `Recovered legacy orchestrator task ${task.id} through Execution Router`, 'orchestrator', { ageMs: repair.ageMs, adapter: repair.externallyCompleted || repair.blocked ? undefined : 'execution-router' }, { agent: 'relay', component: 'agents-relay' }));
+            : repair.failed
+                ? `Failed legacy RUNNING orchestrator task ${task.id}; worker outcome is unknown and Troubleshooter diagnosis is required`
+                : `Recovered legacy orchestrator task ${task.id} through Execution Router`, 'orchestrator', { ageMs: repair.ageMs, adapter: repair.externallyCompleted || repair.failed ? undefined : 'execution-router' }, { agent: 'relay', component: 'agents-relay' }));
     }
 }

package/dist/planner.js

@@ -23,7 +23,7 @@ export function semanticTaskTree(tasks) {
 }
 function plannerTrigger(job, manual = false) {
     const consumed = new Set((job.plans ?? []).filter(plan => plan.status === 'SUCCEEDED').flatMap(plan => plan.trigger.source === 'unblock' ? plan.trigger.taskIds ?? [] : []));
-    const unblocked = job.tasks.filter(task => ['DRAFT', 'QUEUED', 'UNBLOCKED'].includes(task.state) && task.unblock && !consumed.has(task.id));
+    const unblocked = job.tasks.filter(task => ['DRAFT', 'QUEUED'].includes(task.state) && task.unblock && !consumed.has(task.id));
     const hasUnblock = unblocked.length > 0 || Boolean(job.changeCycle && !job.changeCycle.consumedByPlannerTaskId);
     const decision = dispatchPlannerTrigger({
         manualPlan: manual && !hasUnblock,

package/dist/projection-outbox.js

@@ -1,4 +1,4 @@
-export const SCHEMA_VERSION = 5;
+export const SCHEMA_VERSION = 6;
 const UNSAFE_QUEUED_KEY_SUFFIX = /:(?:queued|lost):\d+$/;
 /** Logical operation key recovered from a possibly queued/lost idempotency key. */
 export function logicalOperationKey(idempotencyKey) {

package/dist/reconciler-runtime.js

@@ -13,7 +13,7 @@ import { createWorkerStartAck } from './worker-start-ack.js';
 import { monitorExecutionProcess } from './execution-process-tracker.js';
 import { HostInteractiveInvocationCoordinator, hostInvocationPorts } from './interactive-invocation.js';
 import { resumeInteractiveTask } from './interactive-resume.js';
-import { codexFallbackCompatible, persistChatGptPlatformFailure } from './chatgpt-platform-fallback.js';
+import { persistChatGptPlatformFailure } from './chatgpt-platform-fallback.js';
 import { acceptTaskProgress, armInactivityWatchdog, inactivityDeadline, isCorrelatedWorkerEvent, isRecoverableWatchdogFailure } from './task-inactivity-watchdog.js';
 const activeExecutionOwners = new Map();
 import { withExecutionBoundary } from './execution-boundary.js';
@@ -257,7 +257,10 @@ export class ReconcilerRuntimeBase {
         const message = failure instanceof Error ? failure.message : String(failure);
         const currentJob = await this.store.load(jobId);
         const currentTask = currentJob.tasks.find(task => task.id === taskId);
+        const activeExecution = this.live.get(taskId);
         const platformFailure = currentTask?.adapter === 'chatgpt' ? classifyChatGptPlatformFailure(failure, phase) : undefined;
+        const unknownOutcome = phase === 'start-ack' || ['outcome_unknown', 'start_ack_timeout'].includes(platformFailure?.classification ?? '')
+            || (phase === 'delivery' && activeExecution?.executionId === executionId && activeExecution.workerStarted);
         const failureReason = phase === 'start-ack' ? 'worker_start_timeout'
             : /WEBHELM_UNAVAILABLE|webhelm runtime dependency unavailable|webhelm session start returned no session_id|no close frame received or sent/i.test(message)
                 ? 'browser_workspace_unavailable'
@@ -269,19 +272,14 @@ export class ReconcilerRuntimeBase {
         const cleanup = setTimeout(() => this.launchFailureClaims.delete(claim), 60000);
         cleanup.unref();
         const workflowEvent = platformFailure ? 'worker.platform_failure' : phase === 'start-ack' ? 'worker.start_ack_failed' : 'worker.delivery_failed';
-        const usage = this.options.usageSnapshotProvider ? await this.options.usageSnapshotProvider() : undefined;
-        const platformWorkerCompatible = Boolean(platformFailure?.safeToReroute && currentTask && !(currentTask.agentName === 'reviewer' && this.options.reviewer?.threadId)
-            && await codexFallbackCompatible(currentTask, this.options.adapters, await this.store.listAgents(), usage));
         const transition = await this.taskTransitions.apply(jobId, taskId, platformFailure ? 'worker.platform_failure' : workflowEvent, {
             eligible: (_job, task) => task.executionId === executionId,
-            facts: (_job, task) => ({ platformFallbackSafe: task.state === 'QUEUED' && Boolean(platformFailure?.safeToReroute && platformWorkerCompatible && task.attempt < task.maxAttempts) }),
             mutate: (_job, task, decision) => {
                 if (platformFailure)
                     persistChatGptPlatformFailure(task, currentTask, executionId, platformFailure.classification, platformFailure.evidence, platformFailure.safeToReroute);
                 task.error = decision.target === 'QUEUED' ? null : `Worker ${phase} failed: ${message}`;
-                task.failureReason = decision.target === 'BLOCKED'
-                    ? (task.platformFailure?.safeToReroute && currentTask?.state === 'QUEUED' ? 'worker_platform_fallback_unavailable' : 'worker_outcome_unknown')
-                    : failureReason;
+                task.failureReason = unknownOutcome
+                    ? 'worker_outcome_unknown' : platformFailure ? 'worker_platform_failure' : failureReason;
                 task.leaseOwner = null;
                 task.leaseExpiresAt = null;
             },
@@ -300,14 +298,8 @@ export class ReconcilerRuntimeBase {
                 this.clearExecution(taskId, executionId);
             }
         }
-        const runtimeRetry = transition.decision.target === 'QUEUED' ? transition.task : null;
         const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? `Worker ${phase} failed: ${message}`, 'user', { phase, reason: transition.task.failureReason ?? failureReason, workflowEvent, ...(transition.task.platformFailure ? { platformFailure: transition.task.platformFailure } : {}) }, { agent: 'relay', component: 'agents-relay', watchdog: true });
         this.detach(this.emit(event), jobId, taskId, 'worker failure event');
-        if (runtimeRetry) {
-            this.detach(this.emit(eventFor(jobId, taskId, runtimeRetry.parentTaskId, 'task.rerouting', 'queued', 'ChatGPT platform rejection recorded; routing the same Task through Execution Router', 'orchestrator', { previousFailure: transition.task.platformFailure?.classification, executionId, attempt: runtimeRetry.attempt, maxAttempts: runtimeRetry.maxAttempts })), jobId, taskId, 'runtime retry event');
-            this.detach(this.eventCoordinator.accept({ jobId, reason: 'webhelm-runtime-retry' }), jobId, taskId, 'runtime retry reconcile wake');
-            return;
-        }
         this.detach(this.eventCoordinator.accept({ jobId, reason: `worker-${phase}-failure` }), jobId, taskId, 'worker failure reconcile wake');
     }
     async runtimeSettled(jobId, taskId, executionId, result, error) {
@@ -403,11 +395,15 @@ export class ReconcilerRuntimeBase {
     async applyTerminalEvent(event, trustedInternal = false) {
         const liveAtTerminal = this.live.get(event.task_id);
         const terminalEventExecutionId = executionIdFromSource(eventSourceId(event), event.job_id, event.task_id);
-        const transition = await withExecutionBoundary(event.job_id, event.task_id, () => this.taskTransitions.apply(event.job_id, event.task_id, event.type, {
+        const lifecycleEvent = event.type === 'task.blocked'
+            ? (await this.store.load(event.job_id)).tasks.find(task => task.id === event.task_id)?.interactiveInvocation?.status === 'awaiting_decision'
+                ? 'interactive.waiting' : event.type
+            : event.type;
+        const transition = await withExecutionBoundary(event.job_id, event.task_id, () => this.taskTransitions.apply(event.job_id, event.task_id, lifecycleEvent, {
             eligible: (_job, task) => {
                 if (!['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
                     return false;
-                if (event.type === 'task.blocked' && (!trustedInternal || task.agentName !== 'troubleshooter') && task.interactiveInvocation?.status !== 'awaiting_decision')
+                if (event.type === 'task.blocked' && lifecycleEvent !== 'interactive.waiting' && (!trustedInternal || task.agentName !== 'troubleshooter'))
                     return false;
                 if (task.agentName === 'reviewer' && event.type === 'task.completed')
                     return false;
@@ -426,7 +422,7 @@ export class ReconcilerRuntimeBase {
             facts: (_job, task) => {
                 const processExitedAfterPublishedTerminal = task.failureReason === 'worker_exit_without_terminal_event';
                 const freshEnough = processExitedAfterPublishedTerminal || isCorrelatedWorkerEvent(task, event);
-                return { recoverableExecution: isRecoverableWatchdogFailure(task) && freshEnough };
+                return { recoverableExecution: isRecoverableWatchdogFailure(task) && freshEnough, awaitingInteractiveDecision: lifecycleEvent === 'interactive.waiting' && task.interactiveInvocation?.status === 'awaiting_decision' };
             },
             mutate: (job, task) => {
                 const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
@@ -457,7 +453,7 @@ export class ReconcilerRuntimeBase {
                     task.error = event.message || `Task ${task.id} failed`;
                     task.failureReason = typeof event.data?.reason === 'string' ? event.data.reason : undefined;
                 }
-                else if (event.type === 'task.blocked') {
+                else if (event.type === 'task.blocked' && lifecycleEvent !== 'interactive.waiting') {
                     task.error = event.message || `Task ${task.id} blocked`;
                     const data = event.data ?? {};
                     const head = ['candidate_head', 'candidate_head_sha', 'pr_head', 'head_sha']
@@ -484,7 +480,7 @@ export class ReconcilerRuntimeBase {
         if (event.type === 'task.completed')
             await this.deliverContinuation(transition.job, transition.task);
         const reviewWorker = transition.task.agentName === 'reviewer';
-        return { applied: true, reconcile: !reviewWorker || event.type === 'task.failed', reason: reviewWorker ? `${event.type}.review-worker` : event.type, reconcileMode: reviewWorker ? undefined : 'detached' };
+        return { applied: true, reconcile: lifecycleEvent !== 'interactive.waiting' && (!reviewWorker || event.type === 'task.failed'), reason: reviewWorker ? `${event.type}.review-worker` : event.type, reconcileMode: reviewWorker || lifecycleEvent === 'interactive.waiting' ? undefined : 'detached' };
     }
     terminalWait(taskId, executionId, launchBarrier) {
         let resolve;

package/dist/relay-store.js

@@ -2,6 +2,7 @@ import { 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';
+import { migrateLegacyBlockedTasks } from './legacy-blocked-task-migration.js';
 import { dirname } from 'node:path';
 import { mkdirSync } from 'node:fs';
 import { recordPublicationInDatabase, loadPublicationFromDatabase, listPublicationEventsFromDatabase } from './publication-store.js';
@@ -70,6 +71,7 @@ export class SQLiteRelayStore {
         }
         else
             this.migrate();
+        migrateLegacyBlockedTasks(this.db);
         this.outbox = new ProjectionOutbox(this.db, scopeJobId);
         this.outbox.resetProcessing(new Date().toISOString());
     }

package/dist/relayd-control.js

@@ -124,11 +124,8 @@ export function createWorkspaceControl(deps) {
             const blocked = job.tasks.filter(isEffectivelyBlocked);
             if (!blocked.length)
                 throw new Error(`Job ${job.id} has no effective BLOCKED work task`);
-            if (job.executionMode === 'autonomous')
-                await unblockAutonomousTasks({ store, job, tasks: blocked, trigger: { source: 'cli', reason } });
-            else
-                for (const task of blocked)
-                    await unblockTask({ store, job, task, trigger: { source: 'cli', reason } });
+            for (const task of blocked)
+                await unblockTask({ store, job, task, trigger: { source: 'cli', reason } });
             const refreshed = await store.load(jobId);
             for (const task of blocked)
                 await publishTaskUnblocked(bus, refreshed, task.id, reason);

package/dist/task-actions.js

@@ -186,8 +186,8 @@ export async function dispatchTaskAction(store, request) {
             const task = current.tasks.find(item => item.id === request.taskId);
             if (!task)
                 throw new Error(`Task ${request.taskId} not found`);
+            const recovery = request.id === TASK_RECOVER_ACTION && request.recoveryTaskId ? current.tasks.find(item => item.id === request.recoveryTaskId) : undefined;
             if (request.id === TASK_RECOVER_ACTION) {
-                const recovery = request.recoveryTaskId ? current.tasks.find(item => item.id === request.recoveryTaskId) : undefined;
                 if (!recovery || recovery.agentName !== 'troubleshooter' || recovery.parentTaskId !== task.id || !['QUEUED', 'RUNNING'].includes(recovery.state))
                     throw new Error(`task recover requires an active Troubleshooter recovery for ${task.id}`);
             }
@@ -198,7 +198,11 @@ export async function dispatchTaskAction(store, request) {
                 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}` };
+                if (!recovery)
+                    throw new Error(`task recover requires an active Troubleshooter recovery for ${task.id}`);
+                if (!recovery.executionId)
+                    throw new Error(`Troubleshooter ${recovery.id} has no current execution for a fresh resolution`);
+                const proposal = { path: 'exact_original_retry', targetTaskId: task.id, recoveryExecutionId: recovery.executionId, 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 }); recordRecoveryRouting(task, request); task.resolution = { ...materializeResolution(task, proposal, 'troubleshooter'), state: 'resolved' }; } });
                 if (!decision.accepted)
                     throw new Error(`Task resolution graph rejected exact-original recovery for ${task.id}`);
@@ -232,7 +236,9 @@ export async function dispatchTaskAction(store, request) {
         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))
             throw new Error(`task recover requires an active Troubleshooter recovery for ${task.id}`);
-        const proposal = { path: 'exact_original_retry', targetTaskId: task.id, rootCause: task.failureReason ?? task.error ?? 'durable failure', solution: `Recover exact original Task via ${request.recoveryTaskId}` };
+        if (!recovery.executionId)
+            throw new Error(`Troubleshooter ${recovery.id} has no current execution for a fresh resolution`);
+        const proposal = { path: 'exact_original_retry', targetTaskId: task.id, recoveryExecutionId: recovery.executionId, 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 }); recordRecoveryRouting(task, request); task.resolution = { ...materializeResolution(task, proposal, 'troubleshooter'), state: 'resolved' }; } });
         if (!decision.accepted)
             throw new Error(`Task resolution graph rejected exact-original recovery for ${task.id}`);

package/dist/task-recovery.js

@@ -52,7 +52,7 @@ export async function requestTroubleshooterEscalation(store, jobId, recoveryTask
         if (!['QUEUED', 'RUNNING', 'FAILED'].includes(recovery.state))
             throw new Error(`Troubleshooter ${recoveryTaskId} cannot escalate from ${recovery.state}`);
         if (original) {
-            const proposal = { path: 'escalation_gate', targetTaskId: original.id, rootCause: request.context.trim(), solution: request.requiredAction.trim() };
+            const proposal = { path: 'escalation_gate', targetTaskId: original.id, recoveryExecutionId: recovery.executionId ?? undefined, rootCause: request.context.trim(), solution: request.requiredAction.trim() };
             const decision = dispatchTaskResolutionSync(original, proposal, 'troubleshooter', {
                 createEscalationGate: () => { original.resolution = materializeResolution(original, proposal, 'troubleshooter', now); },
             });

package/dist/types.js

@@ -5,13 +5,19 @@ export function taskOverallTimeoutMs(size, reasoning) { return storySizeTimeoutM
 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;
     const legacy = task;
-    if (legacy.state !== 'UNBLOCKED')
-        return task;
-    legacy.state = executionMode === 'autonomous' ? 'DRAFT' : 'QUEUED';
-    // Preserve the historical execution count when upgrading old snapshots.
-    task.maxAttempts = Math.max(3, task.maxAttempts ?? 0, task.attempt + 1);
-    task.unblock = task.unblock ? { ...task.unblock, event: 'task.unblocked' } : undefined;
+    if (legacy.state === 'UNBLOCKED') {
+        legacy.state = task.agentName === 'troubleshooter' ? 'QUEUED' : 'FAILED';
+        task.failureReason ??= 'legacy_unblocked_task_requires_recovery';
+        task.maxAttempts = Math.max(3, task.maxAttempts ?? 0, task.attempt + 1);
+        task.unblock = task.unblock ? { ...task.unblock, event: 'task.unblocked' } : undefined;
+    }
+    if (legacy.state === 'BLOCKED' && task.kind !== 'planner' && task.agentName !== 'troubleshooter') {
+        legacy.state = 'FAILED';
+        task.failureReason ??= task.failureReason === 'worker_outcome_unknown' ? task.failureReason : 'legacy_ordinary_blocked';
+        task.error ??= 'Legacy ordinary Task was BLOCKED; preserved as FAILED pending Troubleshooter diagnosis.';
+    }
     return task;
 }
 export function assertJobLifecycleTransition(from, to) { assertV2StateTransition(jobLifecycleV2.graph, from, to, 'job'); }