agents-relay 2.0.156 → 2.0.158

package/dist/planner-recovery.js

@@ -9,7 +9,7 @@ export function createFailedPlanRecovery(job, plan) {
         throw Error('Plan recovery identity already exists');
     const now = new Date().toISOString();
     return createTaskEntity(job, {
-        jobId: job.id, id, title: 'Diagnose and recover failed Planner round',
+        jobId: job.id, id, title: 'Troubleshoot',
         recoveryPlanId: plan.id,
         kind: 'work', priority: 'P0', storySize: 'M', projectName: job.title,
         agentName: 'troubleshooter', parentTaskId: null, dependencies: [],

package/dist/planner-runtime.js

@@ -71,7 +71,7 @@ export async function finishPlanner(ports, jobId, planId, executionId, error, ra
         ports.live.delete(planId); };
     const job = await ports.store.load(jobId);
     const plan = (job.plans ?? []).find(item => item.id === planId);
-    if (!plan || plan.status !== "PLANNING" || plan.executionId !== executionId) {
+    if (!plan || (plan.executionId !== executionId && !(raw?.cliApplied && plan.status === 'SUCCEEDED'))) {
         releaseLive();
         if (cliApply)
             throw new Error(`Plan ${planId} is not owned by this active execution`);
@@ -118,6 +118,14 @@ export async function finishPlanner(ports, jobId, planId, executionId, error, ra
         if (retry && !plan.manualPlanning)
             ports.detach(ports.reconcile(jobId), jobId, planId, 'planner retry reconciliation');
     };
+    if (raw?.cliApplied) {
+        if (plan.status !== 'SUCCEEDED') {
+            releaseLive();
+            throw new Error(`Planner reported CLI application, but Plan ${planId} is ${plan.status}`);
+        }
+        releaseLive();
+        return;
+    }
     if (error) {
         if (cliApply)
             throw error;

package/dist/planner.js

@@ -18,12 +18,12 @@ export function semanticTaskTree(tasks) {
     const ids = new Set(work.map(task => task.id));
     return {
         roots: work.filter(task => !task.parentTaskId || !ids.has(task.parentTaskId)).map(task => task.id),
-        tasks: work.map(task => ({ id: task.id, title: task.title, parent_task_id: task.parentTaskId, state: task.state, dependencies: [...task.dependencies], planning_decision_id: task.planningDecisionId, planning_round: task.planningRound, review: task.review })),
+        tasks: work.map(task => ({ id: task.id, title: task.title, parent_task_id: task.parentTaskId, state: task.state, dependencies: [...task.dependencies], planning_decision_id: task.planningDecisionId, planning_round: task.planningRound, review: task.review, resolution_classification: task.resolutionClassification })),
     };
 }
 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,
@@ -107,6 +107,7 @@ export function materializePlannerChild(job, planner, spec, executionContext) {
     const round = 'round' in planner ? planner.round : planner.planningRound ?? 1;
     const plannerHeadSha = 'round' in planner ? planner.headSha : undefined;
     const reviewHeadSha = spec.agentName === 'reviewer' && !(spec.dependencies?.length) ? plannerHeadSha ?? job.headSha : undefined;
+    const objectiveRoot = spec.agentName === 'reviewer' ? job.tasks.find(task => task.kind !== 'planner' && task.agentName !== 'reviewer' && task.agentName !== 'troubleshooter' && !task.parentTaskId) : undefined;
     const resolution = spec.resolution;
     if (resolution) {
         const target = resolution.targetTaskId ? job.tasks.find(task => task.id === resolution.targetTaskId) : undefined;
@@ -115,7 +116,7 @@ export function materializePlannerChild(job, planner, spec, executionContext) {
         validateResolutionProposal(job, target, resolution);
     }
     const reviewerThread = spec.agentName === 'reviewer' ? prepareReviewerThreadDelivery(job, { id: spec.id, agentName: spec.agentName, reviewHeadSha }) : undefined, 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.title, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, agentGraph: spec.agentGraph, review: spec.review, parentTaskId: spec.parentTaskId ?? null, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: 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, 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 });
 }
 export function planningSpec(task) {
     if (!task.output)
@@ -386,7 +387,7 @@ export function validatePlannerHierarchy(existing, specs) {
 /** Planner may only materialize a new business Task while unresolved work is either
  * explicitly resolved in this round or already owned by an active resolution path. */
 export function validatePlannerResolutionMaterialization(existing, specs) {
-    const unresolved = existing.filter(task => unresolvedTask(task) && ['FAILED', 'BLOCKED'].includes(task.state));
+    const unresolved = existing.filter(task => unresolvedTask(task) && ['FAILED', 'BLOCKED'].includes(task.state) && !task.resolutionClassification);
     if (unresolved.length === 0)
         return;
     const resolvedIds = new Set(specs.map(spec => spec.resolution?.targetTaskId).filter((id) => Boolean(id)));
@@ -416,6 +417,7 @@ export function plannerInput(context) {
     const project = context.executionContext?.project;
     return JSON.stringify({
         objective: context.objective,
+        apply_cli: context.planExecution ? `agents-relay plan apply --repo ${context.job.repository} --pr ${context.job.prNumber} --id ${context.job.id} --plan-id ${context.planExecution.planId} --execution-id ${context.planExecution.executionId} --file PATH` : undefined,
         plan_execution: context.planExecution, retry_feedback: context.retryFeedback,
         caller_prompt: context.guidance,
         previous_planner_task_id: context.previousPlannerTaskId,
@@ -449,6 +451,7 @@ export function plannerInput(context) {
                 assessment: boundedText(task.plannerResult.assessment),
                 next_task_ids: task.plannerResult.next_tasks.map(item => item.id),
             } : undefined,
+            resolution_classification: task.resolutionClassification,
             error: boundedText(task.error, 2000),
             blocked_baseline: task.blockedBaseline,
             unblock: task.unblock,
@@ -470,12 +473,10 @@ export class CommandObjectivePlanner {
             child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
             child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
             child.on('error', reject);
-            child.on('close', code => code === 0 ? (() => { try {
-                resolve(parsePlannerOutput(stdout));
-            }
-            catch (error) {
-                reject(error);
-            } })() : reject(new Error(stderr.trim() || `Planner exited ${code}`)));
+            child.on('close', code => code === 0 ? (() => { const expected = context.planExecution ? `PLAN_APPLIED:${context.planExecution.planId}:${context.planExecution.executionId}` : ''; if (stdout.trim() !== expected || !expected) {
+                reject(new Error('Planner command must commit its proposal through agents-relay plan apply and return the matching PLAN_APPLIED receipt'));
+                return;
+            } resolve({ objective_status: 'satisfied', assessment: 'Plan committed through the authorized CLI action.', next_tasks: [], unblocks: [], cliApplied: true }); })() : reject(new Error(stderr.trim() || `Planner exited ${code}`)));
             child.stdin?.end(plannerInput(context));
         });
     }
@@ -539,18 +540,12 @@ export class AgentObjectivePlanner {
                 resolve(finalMessage);
             });
         });
-        const parseAndCheck = (raw) => { const result = parsePlannerOutput(raw); validatePlannerResolutionMaterialization(context.tasks, result.next_tasks); return result; };
-        let response = await runAgent(prompt);
-        for (let retry = 0; retry <= 3; retry++) {
-            try {
-                return parseAndCheck(response);
-            }
-            catch (error) {
-                if (signal.aborted || retry === 3)
-                    throw new Error(`Planner validation failed after ${retry} corrections: ${error instanceof Error ? error.message : String(error)}`);
-                response = await runAgent(`${prompt}\n\n## Fix validation error (correction ${retry + 1} of 3)\n${error instanceof Error ? error.message : String(error)}\nPrevious JSON:\n${response.slice(0, 12000)}\nReturn exactly one complete Planner JSON object. Correct all schema, title, resolution, and dependency requirements; do not remove valid work or bypass safeguards.`);
-            }
-        }
-        throw new Error('Planner correction exhausted');
+        if (!context.planExecution)
+            throw new Error('Planner execution is missing its durable Plan and execution identity');
+        const response = await runAgent(prompt);
+        const expected = `PLAN_APPLIED:${context.planExecution.planId}:${context.planExecution.executionId}`;
+        if (response !== expected)
+            throw new Error('Planner must commit its proposal with the authorized `agents-relay plan apply` CLI action and return only the matching PLAN_APPLIED receipt');
+        return { objective_status: 'satisfied', assessment: 'Plan committed through the authorized CLI action.', next_tasks: [], unblocks: [], cliApplied: true };
     }
 }

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-review.js

@@ -146,14 +146,15 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             reviewPrNumber > 0 ? `Review PR #${reviewPrNumber} at exactly head SHA ${headSha}.` : `Review the local Job artifact at exactly head SHA ${headSha}.`,
             `Review head SHA: ${headSha}`,
             'Job objective: ' + (job.objective ?? job.description ?? job.title),
+            '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 treat historical failed attempts as current artifact defects; distinguish preserved baseline files from implementation.',
         ].join('\n\n');
         const task = createTaskEntity(job, {
-            jobId: job.id, id, title: `Review ${headSha.slice(0, 8)}`, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'reviewer',
-            parentTaskId: null, dependencies: reviewGateTasks.map(item => item.id), capabilities: ['review'],
+            jobId: job.id, id, title: 'Review', kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'reviewer',
+            parentTaskId: reviewGateTasks.find(item => !item.parentTaskId)?.id ?? null, dependencies: reviewGateTasks.map(item => item.id), capabilities: ['review'],
             workerSelection: reviewerRouting.selection, adapter: reviewerRouting.candidate.adapter,
             input,
             output: { kind: 'task_pr' }, routing: reviewerRouting.candidate.routing, continuation: null, continuationDeliveredAt: null,
@@ -163,7 +164,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             error: null, timeoutMs: this.options.reviewer?.timeoutMs ?? storySizeTimeoutMs('M'), createdAt: now, updatedAt: now
         });
         await this.store.appendTask(task);
-        await this.emit(eventFor(job.id, id, null, 'review.created', 'queued', 'Final review task ' + id + ' created for ' + headSha + ' using ' + reviewerRouting.reason, 'orchestrator', { headSha, agentName: 'reviewer', reviewerRouting: { workerId: reviewerRouting.selection.workerId, reason: reviewerRouting.reason, selectedBy: reviewerRouting.selection.selectedBy } }));
+        await this.emit(eventFor(job.id, id, task.parentTaskId, 'review.created', 'queued', 'Final review task ' + id + ' created for ' + headSha + ' using ' + reviewerRouting.reason, 'orchestrator', { headSha, agentName: 'reviewer', reviewerRouting: { workerId: reviewerRouting.selection.workerId, reason: reviewerRouting.reason, selectedBy: reviewerRouting.selection.selectedBy } }));
         return id;
     }
     async projectedReviewHeadReady(job, headSha) {

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/reconciler.js

@@ -137,7 +137,7 @@ export class Reconciler extends ReconcilerReviewBase {
             }
             for (const recovery of pendingTroubleshooterTasks(await this.store.load(jobId))) {
                 await this.store.appendTask(recovery);
-                await this.emit(eventFor(job.id, recovery.id, null, "troubleshooter.created", "queued", "Troubleshooter task " + recovery.id + " created for failed/blocked work", "orchestrator", { agentName: "troubleshooter" }));
+                await this.emit(eventFor(job.id, recovery.id, recovery.parentTaskId, "troubleshooter.created", "queued", "Troubleshooter task " + recovery.id + " created for failed/blocked work", "orchestrator", { agentName: "troubleshooter", originalTaskId: recovery.parentTaskId }));
             }
             {
                 const recoveryJob = await this.store.load(jobId);
@@ -273,8 +273,8 @@ export class Reconciler extends ReconcilerReviewBase {
         }
         return this.store.load(jobId);
     }
-    async planJob(jobId, guidance) {
-        return executeManualPlan(this.store, jobId, guidance, this.options.plannerTimeoutMs ?? storySizeTimeoutMs('M'), (job, plan) => this.launchPlanner(job, plan));
+    async planJob(jobId, guidance, cleanHistory) {
+        return executeManualPlan(this.store, jobId, guidance, this.options.plannerTimeoutMs ?? storySizeTimeoutMs('M'), (job, plan) => this.launchPlanner(job, plan), cleanHistory);
     }
     async maybeCreatePlanner(job) {
         const pending = pendingPlan(job);

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

@@ -4,7 +4,7 @@ import { openLocalManagedStore } from './local-managed-store.js';
 import { relayStoreDirectory } from './relay-store.js';
 import { normalizeThreadId } from './reviewer-thread.js';
 import { publishTaskBlocked } from './cli-support.js';
-import { supersedeCancelledTask } from './task-actions.js';
+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) {
@@ -109,7 +109,8 @@ export function createWorkspaceControl(deps) {
         if (command === 'job.plan') {
             const reconciler = makeReconciler(store, concurrency);
             try {
-                const planned = await reconciler.planJob(jobId, typeof body.guidance === 'string' && body.guidance.trim() ? body.guidance : undefined);
+                const cleanHistory = Array.isArray(body.cleanHistory) ? body.cleanHistory : undefined;
+                const planned = await reconciler.planJob(jobId, typeof body.guidance === 'string' && body.guidance.trim() ? body.guidance : undefined, cleanHistory);
                 await pool.reconcileLocalJob(jobId, 'control.job.plan');
                 return planned.round;
             }
@@ -124,11 +125,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);
@@ -153,6 +151,15 @@ export function createWorkspaceControl(deps) {
             await pool.reconcileLocalJob(jobId, 'control.task.supersede');
             return await store.load(jobId);
         }
+        if (command === 'task.classify') {
+            const taskId = typeof body.taskId === 'string' ? body.taskId : '';
+            const raw = body.classification;
+            if (!taskId || !raw || (raw.kind !== 'superseded' && raw.kind !== 'invalid') || typeof raw.targetTaskId !== 'string' || typeof raw.evidence !== 'string' || typeof raw.reason !== 'string')
+                throw new Error('task classify requires taskId, classification, targetTaskId, evidence, and reason');
+            await classifyFailedTask(store, jobId, taskId, { kind: raw.kind, targetTaskId: raw.targetTaskId, evidence: raw.evidence, reason: raw.reason });
+            await pool.reconcileLocalJob(jobId, 'control.task.classify');
+            return await store.load(jobId);
+        }
         if (command === 'task.recover') {
             const taskId = typeof body.taskId === 'string' ? body.taskId : '';
             const recoveryTaskId = typeof body.recoveryTaskId === 'string' ? body.recoveryTaskId : '';

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

@@ -17,7 +17,7 @@ export async function createSingleJobTaskControl(jobId, store, reconciler, bus)
         unblockAutonomousTasks: unblock.unblockAutonomousTasks, unblockTask: unblock.unblockTask,
         publishTaskUnblocked, dispatchTaskAction,
     });
-    const allowed = new Set(['task.unblock', 'task.recover', 'task.escalate', 'task.resume-troubleshooter']);
+    const allowed = new Set(['task.unblock', 'task.recover', 'task.escalate', 'task.resume-troubleshooter', 'task.classify']);
     return async (body) => {
         if (!allowed.has(String(body.command ?? '')))
             throw new Error('Single-Job control command not supported');

package/dist/task-actions.js

@@ -1,6 +1,7 @@
 import { extendRetryBudget, transitionTaskEvent, tryTransitionTaskEvent } from './scheduler.js';
 import { selectRelatedTaskMutations } from './workflow/task-action-policy.js';
 import { dispatchTaskResolutionSync, materializeResolution } from './workflow/task-resolution.js';
+import { classifyTaskResolution } from './workflow/task-resolution.js';
 export const TASK_RETRY_ACTION = 'task.retry';
 export const TASK_RECOVER_ACTION = 'task.recover';
 export const TASK_UNBLOCK_RETRY_ACTION = 'task.unblock.retry';
@@ -8,6 +9,24 @@ export const TASK_CANCEL_ACTION = 'task.cancel';
 export const TASK_RELEASE_ACTION = 'task.release';
 export const TASK_HOLD_ACTION = 'task.hold';
 export const TASK_QUEUE_ACTION = 'task.queue';
+export async function classifyFailedTask(store, jobId, taskId, classification) {
+    if (!store.mutateJob)
+        throw new Error('Task resolution classification requires atomic SQLite mutation');
+    let changed;
+    const job = await store.mutateJob(jobId, current => {
+        const task = current.tasks.find(item => item.id === taskId);
+        if (!task)
+            throw new Error(`Task ${taskId} not found`);
+        if (classification.targetTaskId === task.id || !current.tasks.some(item => item.id === classification.targetTaskId))
+            throw new Error('Task classification targetTaskId must identify a different durable Task in this Job');
+        classifyTaskResolution(task, classification);
+        changed = structuredClone(task);
+        return current;
+    });
+    if (!changed)
+        throw new Error(`Task ${taskId} classification was not committed`);
+    return { job, task: changed };
+}
 function lifecycleRejection(task, action) {
     return new Error(`Task ${task.id} is not ${action} (${task.state})`);
 }
@@ -186,8 +205,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 +217,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 +255,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/troubleshooter.js

@@ -92,7 +92,7 @@ export function pendingTroubleshooterTasks(job) {
         recoveries.push(createTaskEntity(job, {
             jobId: job.id,
             id,
-            title: `Recover task ${task.id}`,
+            title: 'Troubleshoot',
             recoveryForAttempt: task.attempt,
             kind: 'work',
             priority: 'P0',

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'); }

package/dist/unblock.js

@@ -2,7 +2,7 @@ import { applyTaskUnblockRetrySnapshot } from './task-actions.js';
 import { tryTransitionTaskEvent } from './scheduler.js';
 import { dispatchAuthoritativeUnblock } from './workflow/authoritative-unblock-v2.js';
 import { hasPendingTroubleshooterEscalation } from './task-recovery.js';
-export function isEffectivelyBlocked(task) { return task.kind !== 'planner' && task.state === 'BLOCKED'; }
+export function isEffectivelyBlocked(task) { return task.kind !== 'planner' && task.agentName === 'troubleshooter' && task.state === 'BLOCKED'; }
 function assertNoPendingHumanEscalation(tasks) {
     if (tasks.some(task => task.agentName === 'troubleshooter' && task.escalation?.status === 'pending'))
         throw new Error('Blocked Troubleshooter requires an authorized human response; use task unblock --response');
@@ -32,7 +32,7 @@ function unblockFacts(job, tasks, currentHeadSha, reason) {
 }
 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 tasks = job.tasks.filter(task => task.unblock && !consumed.has(task.id) && ['DRAFT', 'QUEUED', 'UNBLOCKED'].includes(task.state));
+    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;
         if (!legacy || legacy.consumedByPlannerTaskId)
@@ -60,43 +60,8 @@ export function unblockNeedsNewPlan(job) {
         && latest.trigger.taskIds?.some(id => pending.taskIds?.includes(id)));
 }
 export async function unblockAutonomousTasks(options) {
-    const { store, job, trigger } = options;
-    const tasks = options.tasks.filter(isEffectivelyBlocked);
-    if (tasks.length === 0)
-        throw new Error('No effective BLOCKED work task is available to unblock');
-    assertNoPendingHumanEscalation(tasks);
-    const now = options.now ?? new Date().toISOString();
-    const currentHeadSha = await store.headSha?.() ?? job.headSha ?? null;
-    const facts = unblockFacts(job, tasks, currentHeadSha, trigger.reason);
-    const apply = (current) => {
-        for (const requested of tasks) {
-            const task = current.tasks.find(item => item.id === requested.id);
-            if (!task || !isEffectivelyBlocked(task))
-                throw new Error(`Task ${requested.id} changed before authoritative unblock`);
-            const baseline = baselineFor(task);
-            if (!tryTransitionTaskEvent(task, 'task.unblocked', { autonomousJob: true }).accepted)
-                throw new Error(`Task ${task.id} cannot be authoritatively unblocked`);
-            task.blockedBaseline = baseline;
-            task.unblock = { event: 'task.unblocked', at: now, source: trigger.source, reason: trigger.reason, baseline, currentHeadSha: currentHeadSha ?? undefined, facts, blockerJobId: trigger.blockerJobId, resolution: trigger.resolution };
-            task.updatedAt = now;
-            delete task.blockedBy;
-        }
-        current.updatedAt = now;
-    };
-    if (store.mutateJob) {
-        const committed = await store.mutateJob(job.id, current => { apply(current); return current; });
-        Object.assign(job, structuredClone(committed));
-    }
-    else {
-        apply(job);
-        for (const task of tasks)
-            await store.saveTask(task);
-    }
-    const planTrigger = unconsumedUnblockTrigger(job) ?? {
-        source: 'unblock', taskIds: tasks.map(task => task.id), reason: trigger.reason,
-        facts, currentHeadSha: currentHeadSha ?? undefined, unblockSource: trigger.source,
-    };
-    return planTrigger;
+    void options;
+    throw new Error('Ordinary Tasks cannot be authoritatively unblocked; only a blocked Troubleshooter can resume');
 }
 export async function unblockTask(options) {
     if (!isEffectivelyBlocked(options.task))
@@ -106,11 +71,7 @@ export async function unblockTask(options) {
         throw new Error(`Task ${options.task.id} cannot be directly unblocked while its Troubleshooter is awaiting human action`);
     }
     let result;
-    const decision = await dispatchAuthoritativeUnblock(options.job.executionMode === 'autonomous', async (actionId) => {
-        if (actionId === 'unblock.replan') {
-            result = { replanning: true, planTrigger: await unblockAutonomousTasks({ store: options.store, job: options.job, tasks: [options.task], trigger: options.trigger, now: options.now }) };
-            return {};
-        }
+    const decision = await dispatchAuthoritativeUnblock(options.task.agentName === 'troubleshooter', async (actionId) => {
         if (actionId === 'unblock.retry') {
             const now = options.now ?? new Date().toISOString();
             const currentHeadSha = await options.store.headSha?.() ?? options.job.headSha ?? null;

package/dist/workflow/authoritative-unblock-v2.js

@@ -4,17 +4,16 @@ import { dispatchWorkflowGraph, dispatchWorkflowGraphSync } from './dispatcher.j
 const source = readFileSync(new URL('../../workflow/authoritative-unblock.mmd', import.meta.url), 'utf8');
 const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
 export const authoritativeUnblockV2 = new GraphRuntime(source, {
-    states: new Set(['blocked', 'autonomous_replan', 'fixed_retry']),
-    guards: { autonomousJob: boolGuard('autonomousJob') },
+    states: new Set(['blocked', 'troubleshooter_queued']),
+    guards: { blockedTroubleshooter: boolGuard('blockedTroubleshooter') },
     actions: {
-        'unblock.replan': { id: 'unblock.replan' },
         'unblock.retry': { id: 'unblock.retry' },
     },
     events: { 'task.authoritative_unblock': { id: 'task.authoritative_unblock' } },
 });
-export async function dispatchAuthoritativeUnblock(autonomousJob, executeAction) {
-    return dispatchWorkflowGraph(authoritativeUnblockV2, { initialState: 'blocked', input: { transport: 'event', id: 'task.authoritative_unblock', payload: {} }, graphName: 'authoritative-unblock', durableFacts: { autonomousJob }, executeAction });
+export async function dispatchAuthoritativeUnblock(blockedTroubleshooter, executeAction) {
+    return dispatchWorkflowGraph(authoritativeUnblockV2, { initialState: 'blocked', input: { transport: 'event', id: 'task.authoritative_unblock', payload: {} }, graphName: 'authoritative-unblock', durableFacts: { blockedTroubleshooter }, executeAction });
 }
-export function decideAuthoritativeUnblock(autonomousJob) {
-    return dispatchWorkflowGraphSync(authoritativeUnblockV2, { initialState: 'blocked', input: { transport: 'event', id: 'task.authoritative_unblock', payload: {} }, graphName: 'authoritative-unblock', durableFacts: { autonomousJob } });
+export function decideAuthoritativeUnblock(blockedTroubleshooter) {
+    return dispatchWorkflowGraphSync(authoritativeUnblockV2, { initialState: 'blocked', input: { transport: 'event', id: 'task.authoritative_unblock', payload: {} }, graphName: 'authoritative-unblock', durableFacts: { blockedTroubleshooter } });
 }