agents-relay 2.0.76 → 2.0.78

package/dist/blockers.js

@@ -1,6 +1,7 @@
 import { applyTaskReleaseAction, applyTaskUnblockRetryAction, dispatchTaskAction } from './task-actions.js';
 import { isEffectivelyBlocked, unblockAutonomousTasks, unblockTask } from './unblock.js';
 import { dispatchBlockerResolution } from './workflow/blocker-resolution-v2.js';
+import { dispatchTaskResolutionSync, materializeResolution } from './workflow/task-resolution.js';
 function dependentKey(value) {
     return `${value.repository}#${value.prNumber}:${value.jobId}:${value.taskId}:a${value.blockedAttempt}`;
 }
@@ -16,6 +17,12 @@ export async function registerBlockerDependency(options) {
     if (!['DRAFT', 'FAILED', 'BLOCKED'].includes(task.state))
         throw new Error(`Dependent task ${task.id} is not waiting/blocked/failed (${task.state})`);
     const now = options.now ?? new Date().toISOString();
+    const resolutionProposal = { path: 'blocker_job_dependency', targetTaskId: task.id, targetJobId: blocker.id, mode: options.resolutionMode ?? blocker.blockerResolutionMode ?? 'merge' };
+    const resolutionDecision = dispatchTaskResolutionSync(task, resolutionProposal, 'blocker-job', { registerBlockerDependency: () => {
+            task.resolution = { ...materializeResolution(task, resolutionProposal, 'blocker-job', now), state: 'waiting' };
+        } });
+    if (!resolutionDecision.accepted)
+        throw new Error(`Task resolution graph rejected blocker dependency for ${task.id}`);
     const relation = {
         repository: dependentJob.repository,
         prNumber: dependentJob.prNumber,

package/dist/cli-help.js

@@ -60,7 +60,7 @@ Optional: --thread-id THREAD_ID persists a reviewer override; omitted uses Job r
 
 Required: --repo OWNER/REPO, --id JOB_ID, and either --head BRANCH or --pr NUMBER.
 With --head, bind the local source branch and use --base as its local merge target without a GitHub query. With --pr, bind an existing external PR reference as optional metadata without a GitHub query.
-Common: --base BRANCH (default: main), --title TEXT, --objective-file PATH|- (preferred), --objective MARKDOWN (short/simple only), --project-path RELATIVE_PATH, --priority P0|P1|P2|P3, --mode fixed|autonomous, --initial-plan, --no-review, --tag JSON, --reviewer-thread-id ID, --creator-thread-id ID. --objective and --objective-file are mutually exclusive. For a new --head Job, one is required and must contain enough standalone context to complete the Job without the originating chat/thread. Objective Markdown is also the default PR body; --body is an explicit override.
+Common: --base BRANCH (default: main), --title TEXT, --objective-file PATH|- (preferred), --objective MARKDOWN (short/simple only), --project-path RELATIVE_PATH, --priority P0|P1|P2|P3, --mode fixed|autonomous, --initial-plan, --no-review, --tag JSON, --reviewer-thread-id ID, --creator-thread-id ID, --implementation-thread-id ID. --objective and --objective-file are mutually exclusive. For a new --head Job, one is required and must contain enough standalone context to complete the Job without the originating chat/thread. Objective Markdown is also the default PR body; --body is an explicit override.
 Job creation always enables auto-merge. By default it is create-only; --initial-plan follows durable Job creation with the first real Planner round, activates the Job, and publishes the normal wake so Relay can continue without a second orchestrator command. Re-running create against an already healthy Job is idempotent and does not mutate its metadata.
 
 Example:
@@ -68,7 +68,7 @@ Example:
     'job update': `Partially update mutable metadata on a healthy existing Job.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID.
-Mutable: --title, --objective-file PATH|- (preferred) or --objective MARKDOWN, --project-path RELATIVE_PATH, --priority, --mode fixed|autonomous, --schedule, --tag JSON, --auto-merge|--no-auto-merge, --review|--no-review, --reviewer-thread-id ID, --creator-thread-id ID, and continuation options. The objective updates local SQLite; PR body changes are independent external actions.
+Mutable: --title, --objective-file PATH|- (preferred) or --objective MARKDOWN, --project-path RELATIVE_PATH, --priority, --mode fixed|autonomous, --schedule, --tag JSON, --auto-merge|--no-auto-merge, --review|--no-review, --reviewer-thread-id ID, --creator-thread-id ID, --implementation-thread-id ID, and continuation options. The objective updates local SQLite; PR body changes are independent external actions.
 Unspecified fields are preserved. Local Job/PR identity mismatch is rejected.
 
 Example:

package/dist/cli-job-create.js

@@ -58,6 +58,9 @@ export async function ensureManagedGitHubJob(_client, repositoryName, _trustedAu
             ...(options.creatorThreadId
                 ? { creatorThreadId: normalizeThreadId(options.creatorThreadId, 'creator thread ID') }
                 : {}),
+            ...(options.implementationThreadId
+                ? { implementationThreadId: normalizeThreadId(options.implementationThreadId, 'implementation thread ID') }
+                : {}),
             prNumber: pr.number,
             repository: repositoryName,
             continuation: options.continuation ?? null,

package/dist/cli.js

@@ -380,7 +380,7 @@ async function runJobCommand(action, args) {
         const result = await relayControlCommand(args, { command: 'job.create', repository: repo, initialPlan: hasArg(args, '--initial-plan'), options: {
                 id, title: arg(args, '--title') || undefined, objective: objective || undefined, projectPath: arg(args, '--project-path') || undefined,
                 priority: priority(args), executionMode: requestedExecutionMode(args), schedule: scheduleFromArgs(args), tag: jobTagFromArgs(args), reviewEnabled: !hasArg(args, '--no-review'), continuation: continuation(args),
-                reviewerThreadId: hasArg(args, '--reviewer-thread-id') ? arg(args, '--reviewer-thread-id') : undefined, creatorThreadId: hasArg(args, '--creator-thread-id') ? arg(args, '--creator-thread-id') : undefined,
+                reviewerThreadId: hasArg(args, '--reviewer-thread-id') ? arg(args, '--reviewer-thread-id') : undefined, creatorThreadId: hasArg(args, '--creator-thread-id') ? arg(args, '--creator-thread-id') : undefined, implementationThreadId: hasArg(args, '--implementation-thread-id') ? arg(args, '--implementation-thread-id') : undefined,
                 prNumber, head: arg(args, '--head') || undefined, base: arg(args, '--base', 'main'), body: arg(args, '--body') || objective || undefined,
                 localMergeSource: arg(args, '--local-merge-source') || undefined, localMergeTarget: arg(args, '--local-merge-target') || undefined,
             } });
@@ -448,6 +448,8 @@ async function runJobCommand(action, args) {
         job.reviewerThreadId = normalizeThreadId(arg(args, '--reviewer-thread-id'), '--reviewer-thread-id');
     if (hasArg(args, '--creator-thread-id'))
         job.creatorThreadId = normalizeThreadId(arg(args, '--creator-thread-id'), '--creator-thread-id');
+    if (hasArg(args, '--implementation-thread-id'))
+        job.implementationThreadId = normalizeThreadId(arg(args, '--implementation-thread-id'), '--implementation-thread-id');
     if (hasArg(args, '--continue-kind') || hasArg(args, '--continue-target')) {
         const next = continuation(args);
         if (!next)
@@ -455,7 +457,7 @@ async function runJobCommand(action, args) {
         job.continuation = next;
     }
     const patch = {};
-    for (const key of ['title', 'objective', 'projectPath', 'priority', 'executionMode', 'schedule', 'tag', 'autoMerge', 'reviewEnabled', 'reviewerThreadId', 'creatorThreadId', 'continuation', 'localMerge'])
+    for (const key of ['title', 'objective', 'projectPath', 'priority', 'executionMode', 'schedule', 'tag', 'autoMerge', 'reviewEnabled', 'reviewerThreadId', 'creatorThreadId', 'implementationThreadId', 'continuation', 'localMerge'])
         patch[key] = job[key];
     console.log(JSON.stringify(await relayControlCommand(args, { command: 'job.update', jobId: id, patch }), null, 2));
 }

package/dist/dashboard-html.js

@@ -403,7 +403,7 @@ function taskStateField(task){const box=element('div','detail-group');box.append
 function manualOverrideField(task){const rows=Array.isArray(task.manualStateOverrides)?task.manualStateOverrides:[];const last=rows.at(-1);return field('Manual override',last?last.from+' → '+last.to+' · '+relativeTime(last.at):'—');}
 function renderTaskDetail(task){taskDetailRoot.replaceChildren();if(!task){taskDetailRoot.append(element('p','empty',text('Select a task to inspect execution details.')));return;}const routing=task.routing||{};const groups=element('div','detail-groups');groups.append(field('Task',task.id),field('Kind',task.kind||'work'),taskStateField(task),manualOverrideField(task),field('Planning decision',task.planningDecisionId||'—'),field('Planning source',task.planningSource||'—'),field('Planning round',task.planningRound===undefined?'—':String(task.planningRound)),field('Project / agent',value(task.projectName)+' / '+value(task.agentName)),field('Parent task',task.parentTaskId||'root'),field('Adapter',task.adapter),field('Provider / model',value(routing.provider)+' / '+value(routing.model)),field('Reasoning / profile',value(routing.reasoning||routing.profile)),field('Attempt',attemptBudget(task)),field('Dependencies',Array.isArray(task.dependencies)&&task.dependencies.length?task.dependencies.join(', '):'none'),taskCommentField(task),chatField(task));const job=selected();if(task.reviewHeadSha&&job)groups.append(commitField('HEAD commit',job,task.reviewHeadSha));const graph=agentGraphField(task);if(graph)groups.append(graph);if(task.plannerResult)groups.append(field('Objective status',task.plannerResult.objective_status),markdownField('Assessment',task.plannerResult.assessment));if(task.error)groups.append(field('Error',task.error));taskDetailRoot.append(groups);}
 function reviewStatus(job){const review=job?.review;if(!review)return 'Not started';if(review.outcome==='approved'&&review.headSha===job.headSha)return 'MERGE READY · approved';const stale=Array.isArray(job?.tasks)&&job.tasks.some(task=>task.agentName==='reviewer'&&task.reviewHeadSha&&job.headSha&&task.reviewHeadSha!==job.headSha);if(stale)return 'STALE · awaiting review';return String(review.outcome||'pending').replace('_',' ').toUpperCase();}
-function renderSelectedJob(){jobDetail.replaceChildren();const job=selected();if(!job){selectedJobTitle.textContent='';jobDetail.append(element('div','empty',text('No durable jobs discovered.')));buildTree([]);renderTaskDetail(null);return;}selectedJobTitle.textContent=value(job.title||job.id);if(jobSelectionKey(job)!==selectedJob){selectedJob=jobSelectionKey(job);selectedTaskId=null;eventTaskId=null;clearEvents();rememberSelection();}const summary=element('div','job-summary');summary.append(field('PR state',job.githubState||'UNKNOWN'),jobStateField(job),field('Runtime status',job.runtimeStatus||'IDLE'),field('Execution mode',job.executionMode||'fixed'),field('Cadence',cadence(job)),field('Review',reviewStatus(job)),commitField('Review head SHA',job,job.review?.headSha||job.headSha||''),prField(job),field('Repository',job.repository||'—'),field('Last activity',relativeTime(job.updatedAt)),field('Task states',compactCounts(job.tasks)),chatShortcutField(job));jobDetail.append(summary);const selectedTask=(job.tasks||[]).find(task=>task.id===selectedTaskId)||null;if(selectedTaskId&&!selectedTask){selectedTaskId=null;eventTaskId=null;clearEvents();rememberSelection();}buildTree(job.tasks||[]);renderTaskDetail(selectedTask);renderEventScope();}
+function renderSelectedJob(){jobDetail.replaceChildren();const job=selected();if(!job){selectedJobTitle.textContent='';jobDetail.append(element('div','empty',text('No durable jobs discovered.')));buildTree([]);renderTaskDetail(null);return;}selectedJobTitle.textContent=value(job.title||job.id);if(jobSelectionKey(job)!==selectedJob){selectedJob=jobSelectionKey(job);selectedTaskId=null;eventTaskId=null;clearEvents();rememberSelection();}const summary=element('div','job-summary');summary.append(field('PR state',job.githubState||'UNKNOWN'),jobStateField(job),field('Runtime status',job.runtimeStatus||'IDLE'),field('Execution mode',job.executionMode||'fixed'),field('Cadence',cadence(job)),field('Review',reviewStatus(job)),field('Creator thread',job.creatorThreadId||'—'),field('Implementation thread',job.implementationThreadId||'—'),field('Reviewer thread',job.reviewerThreadId||'—'),commitField('Review head SHA',job,job.review?.headSha||job.headSha||''),prField(job),field('Repository',job.repository||'—'),field('Last activity',relativeTime(job.updatedAt)),field('Task states',compactCounts(job.tasks)),chatShortcutField(job));jobDetail.append(summary);const selectedTask=(job.tasks||[]).find(task=>task.id===selectedTaskId)||null;if(selectedTaskId&&!selectedTask){selectedTaskId=null;eventTaskId=null;clearEvents();rememberSelection();}buildTree(job.tasks||[]);renderTaskDetail(selectedTask);renderEventScope();}
 function renderAll(){jobs.sort(compareJobs);syncFilters();renderJobList();renderSelectedJob();syncMobileJobsView();}
 function isCompleteUnmerged(job){return job.runtimeStatus==='MERGE_PENDING';}
 function isTerminalJob(job){return ['COMPLETED','CANCELLED'].includes(job.state)||['MERGED','CLOSED'].includes(job.githubState);}

package/dist/github-branch-projection.js

@@ -0,0 +1,12 @@
+export function authoritativeBranchPushArgs(options) {
+    const refspec = `${options.sourceRef}:refs/heads/${options.branch}`;
+    if (options.remoteHeadSha && options.remoteTreeMatchesBase) {
+        return [
+            'push',
+            'origin',
+            `--force-with-lease=refs/heads/${options.branch}:${options.remoteHeadSha}`,
+            refspec,
+        ];
+    }
+    return ['push', 'origin', refspec];
+}

package/dist/managed-worker-input.js

@@ -36,6 +36,13 @@ ${projectedReview
         : isLocalJob
             ? `Treat the following durable task input as the authoritative work contract; do not query GitHub.\n\n${task.input}`
             : `Retrieve the durable job and task from GitHub before doing the work. Use whatever GitHub access this environment provides: the URLs, a GitHub integration/tool, or GitHub CLI/API. GitHub is the source of truth for task intent and declared output.`}
+\n[Authoritative execution context]
+Job objective: ${job.objective ?? '(none recorded)'}
+Plan: ${task.planningDecisionId ? `${task.planningDecisionId} (round ${task.planningRound ?? 'unknown'})` : 'directly created Task'}
+Task attempt/execution: ${task.attempt}/${task.maxAttempts} / ${task.executionId}
+Dependencies: ${task.dependencies.length ? task.dependencies.join(', ') : 'none'}
+${task.attempt > 1 || task.error ? `Retry summary: prior error=${task.error ?? 'none'}; prior generations=${(task.executionHistory ?? []).map(item => `${item.id}@${item.attempt}`).join(', ') || 'none'}` : 'Retry summary: first attempt'}
+SQLite/RelayStore and the canonical Mermaid Graphs own lifecycle, merge, recovery, and completion decisions. Do not perform Relay-owned merge or completion actions from this worker.
 ${context ? executionContextPrompt(context) + '\n\n' : ''}${selectedAgent ? selectedAgent + '\n\n' : ''}${selectedGraph ? selectedGraph + '\n\n' : ''}${chairPlan ? `[Review Chair execution plan]\n${JSON.stringify(chairPlan, null, 2)}\n\nUse this runtime-discovered panel to create sibling durable specialist Tasks. Preserve each specialistTasks entry as review metadata, keep the target immutable, and synthesize structured results with synthesizeReview semantics before returning the unified revision plan.\n\n` : ''}Follow the resolved project instructions and Agents Relay/events-bus worker contracts.
 [Output contract]
 ${output}

package/dist/planner-runtime.js

@@ -1,7 +1,8 @@
 import { randomUUID } from 'node:crypto';
 import { jobHasActiveExecution } from './job-execution-slot.js';
 import { eventFor } from './events.js';
-import { materializePlannerChild, parsePlannerResult, validatePlannerHierarchy, validatePlannerLifecycleOwnership, validatePlannerProgress } from './planner.js';
+import { materializePlannerChild, parsePlannerResult, validatePlannerHierarchy, validatePlannerLifecycleOwnership, validatePlannerProgress, validatePlannerResolutionMaterialization } from './planner.js';
+import { attachResolutionOwnership } from './workflow/task-resolution.js';
 import { samePlannerChildDefinition } from './planner-child.js';
 import { dispatchJobLifecycleSync } from './workflow/lifecycle.js';
 import { withExecutionBoundary } from './reconciler-runtime.js';
@@ -121,6 +122,7 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
         const result = parsePlannerResult(raw);
         const executionContext = await ports.plannerContext(job, plan);
         validatePlannerHierarchy(job.tasks, result.next_tasks);
+        validatePlannerResolutionMaterialization(job.tasks, result.next_tasks);
         validatePlannerLifecycleOwnership(job, result.next_tasks);
         validatePlannerProgress(job, result);
         if (result.unblocks.length > 0 && !ports.store.registerBlockerDependent)
@@ -154,6 +156,9 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
                     current.changeCycle.consumedByPlannerTaskId = durablePlan.id;
                 }
                 for (const child of children) {
+                    const spec = result.next_tasks.find(item => item.id === child.id);
+                    if (spec?.resolution)
+                        attachResolutionOwnership(current, child, spec.resolution, 'planner');
                     const existing = current.tasks.find(item => item.id === child.id);
                     if (!existing)
                         current.tasks.push(structuredClone(child));
@@ -193,8 +198,12 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
                 await ports.store.saveJob(job);
             }
             for (const child of children)
-                if (!job.tasks.some(item => item.id === child.id))
+                if (!job.tasks.some(item => item.id === child.id)) {
+                    const spec = result.next_tasks.find(item => item.id === child.id);
+                    if (spec?.resolution)
+                        await ports.store.saveTask(attachResolutionOwnership(job, child, spec.resolution, 'planner'));
                     await ports.store.appendTask(child);
+                }
         }
         planCommitted = true;
         // Cross-Job registrations cannot join this Job's SQLite transaction. The

package/dist/planner.js

@@ -3,10 +3,12 @@ import { parseTestInjection } from './e2e-injection.js';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { storySizeTimeoutMs, taskOverallTimeoutMs } from './types.js';
+import { validateResolutionProposal, unresolvedTask } from './workflow/task-resolution.js';
 import { executionContextPrompt } from './execution-context.js';
 import { parseAgentGraph, validateAgentSelection } from './agent-graph.js';
 import { dispatchPlannerTrigger } from './workflow/planner-trigger-v2.js';
 import { createTaskEntity } from './workflow/entity-creation.js';
+import { prepareReviewerThreadDelivery, chatgptThreadRequirements } from './reviewer-thread.js';
 import { spawnOwnedProcess } from './owned-process.js';
 export function semanticTaskTree(tasks) {
     const work = tasks.filter(task => task.kind !== 'planner');
@@ -102,14 +104,22 @@ 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;
-    return createTaskEntity(job, { jobId: job.id, id: spec.id, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, agentGraph: spec.agentGraph, review: spec.review, parentTaskId: spec.parentTaskId ?? null, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: spec.workerRequirements, testInjection: spec.testInjection, adapter: 'codex', 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 });
+    const resolution = spec.resolution;
+    if (resolution) {
+        const target = resolution.targetTaskId ? job.tasks.find(task => task.id === resolution.targetTaskId) : undefined;
+        if (!target || !unresolvedTask(target))
+            throw new Error(`Planner resolution for ${spec.id} must target one unresolved durable Task`);
+        validateResolutionProposal(job, target, resolution);
+    }
+    const reviewerThread = spec.agentName === 'reviewer' ? prepareReviewerThreadDelivery(job, { id: spec.id, agentName: spec.agentName, reviewHeadSha }) : undefined;
+    return createTaskEntity(job, { jobId: job.id, id: spec.id, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, agentGraph: spec.agentGraph, review: spec.review, parentTaskId: spec.parentTaskId ?? null, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: reviewerThread ? chatgptThreadRequirements(spec.workerRequirements) : spec.workerRequirements, testInjection: spec.testInjection, adapter: reviewerThread ? 'chatgpt' : 'codex', chatgptThreadDelivery: reviewerThread, input: spec.input, output: spec.output, continuation: spec.continuation ?? null, continuationDeliveredAt: null, attempt: 0, maxAttempts: spec.maxAttempts ?? 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: spec.timeoutMs ?? taskOverallTimeoutMs(spec.storySize ?? 'M'), createdAt: now, updatedAt: now, planningDecisionId: decisionId, planningSource: source, planningRound: round, reviewHeadSha, resolution: resolution ? { ...resolution, state: 'proposed', owner: 'planner', updatedAt: now } : undefined });
 }
 export function planningSpec(task) {
     if (!task.output && task.adapter !== 'orchestrator')
         throw new Error(`Initial task ${task.id} requires an output contract`);
     if (!['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
         throw new Error(`Initial task ${task.id} requires a supported adapter`);
-    return { id: task.id, parentTaskId: task.parentTaskId, input: task.input, priority: task.priority, storySize: task.storySize, projectName: task.projectName, agentName: task.agentName, agentGraph: task.agentGraph, review: task.review, dependencies: task.dependencies, capabilities: task.capabilities, workerRequirements: task.workerRequirements, testInjection: task.testInjection, adapter: task.adapter, output: task.output ?? { kind: 'task_pr' }, routing: task.routing, continuation: task.continuation, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs };
+    return { id: task.id, parentTaskId: task.parentTaskId, input: task.input, priority: task.priority, storySize: task.storySize, projectName: task.projectName, agentName: task.agentName, agentGraph: task.agentGraph, review: task.review, dependencies: task.dependencies, capabilities: task.capabilities, workerRequirements: task.workerRequirements, testInjection: task.testInjection, adapter: task.adapter, output: task.output ?? { kind: 'task_pr' }, routing: task.routing, continuation: task.continuation, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs, resolution: task.resolution ? { ...task.resolution, state: undefined, owner: undefined, updatedAt: undefined } : undefined };
 }
 function record(value, field = 'result') {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -204,6 +214,20 @@ function routing(value, field) {
             throw new Error(`Planner ${field}.${key} is required`);
     return { provider: route.provider, model: route.model, profile: optionalString(route.profile, `${field}.profile`), reasoning: optionalString(route.reasoning, `${field}.reasoning`), cwd: optionalString(route.cwd, `${field}.cwd`), projectId: optionalString(route.projectId, `${field}.projectId`), decidedBy: route.decidedBy, decidedAt: route.decidedAt };
 }
+function resolutionProposal(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    const root = record(value, field);
+    const path = root.path;
+    if (typeof path !== 'string' || !['exact_original_retry', 'same_job_dependency', 'blocker_job_dependency', 'escalation_gate', 'cancel_supersede'].includes(path))
+        throw new Error(`Planner ${field}.path is invalid`);
+    const stringField = (name) => optionalString(root[name], `${field}.${name}`);
+    const mode = root.mode === undefined ? undefined : String(root.mode);
+    if (mode !== undefined && mode !== 'merge' && mode !== 'verified')
+        throw new Error(`Planner ${field}.mode must be merge or verified`);
+    const list = (name) => root[name] === undefined ? undefined : stringArray(root[name], `${field}.${name}`);
+    return { path: path, targetTaskId: stringField('targetTaskId'), targetJobId: stringField('targetJobId'), mode: mode, rootCause: stringField('rootCause'), solution: stringField('solution'), deviations: list('deviations'), validationEvidence: list('validationEvidence') };
+}
 export function parsePlannerResult(value) {
     const root = record(value, 'result');
     const status = root.objective_status;
@@ -289,7 +313,7 @@ export function parsePlannerResult(value) {
             dependencies: stringArray(task.dependencies, 'dependencies'), capabilities: stringArray(task.capabilities, 'capabilities'), workerRequirements: requirements,
             testInjection: parseTestInjection(task.testInjection ?? task['--test-injection']) ?? optionalString(task.testInjection ?? task['--test-injection'], `next_tasks[${index}].--test-injection`),
             adapter: adapter, output: output, routing: route,
-            continuation: task.continuation, maxAttempts, timeoutMs
+            continuation: task.continuation, maxAttempts, timeoutMs, resolution: resolutionProposal(task.resolution, `next_tasks[${index}].resolution`)
         };
     });
     return { objective_status: status, assessment: root.assessment, next_tasks, unblocks };
@@ -351,6 +375,18 @@ 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));
+    if (unresolved.length === 0)
+        return;
+    const resolvedIds = new Set(specs.map(spec => spec.resolution?.targetTaskId).filter((id) => Boolean(id)));
+    const owned = unresolved.filter(task => task.resolution && ['active', 'waiting'].includes(task.resolution.state));
+    const uncovered = unresolved.filter(task => !resolvedIds.has(task.id) && !owned.some(candidate => candidate.id === task.id));
+    if (uncovered.length > 0 && specs.length > 0)
+        throw new Error(`Planner cannot create sibling replacement work while unresolved Task(s) lack a graph resolution: ${uncovered.map(task => task.id).join(', ')}`);
+}
 export function parsePlannerOutput(output) {
     const trimmed = output.trim();
     const candidate = trimmed.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim();

package/dist/pool.js

@@ -152,9 +152,19 @@ export class RepositoryWorkerPool {
             if (!needsLifecycleReconciliation(job))
                 continue;
             const allowance = Math.max(1, Math.min(capacity, ready || (expiredRunning ? 1 : 0) || 1));
-            await this.reconcileExclusive(job.id, async () => {
-                await this.makeReconciler(store, allowance).reconcile(job.id);
-            });
+            try {
+                await this.reconcileExclusive(job.id, async () => {
+                    await this.makeReconciler(store, allowance).reconcile(job.id);
+                });
+            }
+            catch (error) {
+                observability().record({
+                    stage: 'reconcile', event: 'reconcile.job_failed', level: 'error', outcome: 'failed',
+                    message: `Reconcile failed for ${job.id}: ${errorMessage(error)}`,
+                    correlation: { jobId: job.id, repository: job.repository, prNumber: job.prNumber },
+                    data: { classification: 'job-isolated' },
+                });
+            }
             capacity -= allowance;
         }
     }

package/dist/reconciler-review.js

@@ -9,7 +9,7 @@ import { dispatchReviewLifecycle, reviewOutcome } from './workflow/review-v2.js'
 import { dispatchTaskLifecycleSync } from './workflow/lifecycle.js';
 import { createTaskEntity } from './workflow/entity-creation.js';
 import { localSourceHead, localWorkingHead } from './local-git-merge.js';
-import { chatgptThreadRequirements, resolveReviewerThreadDestination } from './reviewer-thread.js';
+import { chatgptThreadRequirements, resolveReviewerThreadDestination, resolveImplementationTaskThreadDestination, prepareReviewerThreadDelivery } from './reviewer-thread.js';
 import { reviewGenerationMatches } from './review-generation-fence.js';
 export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
     async currentHeadSha(job) {
@@ -74,7 +74,8 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         }).filter(Boolean);
     }
     static normalizeReviewEvidence(event, task) {
-        const headSha = ReconcilerReviewBase.reviewHeadSha(event);
+        const explicitHeadSha = ReconcilerReviewBase.reviewHeadSha(event);
+        const headSha = explicitHeadSha ?? (event.type === 'review.approved' ? task.reviewHeadSha : undefined);
         if (!headSha)
             return null;
         return { headSha, issues: ReconcilerReviewBase.reviewIssues(event) };
@@ -130,16 +131,9 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const reviewGateTasks = implementationTasks(job);
         const reviewThread = resolveReviewerThreadDestination(job, this.options.reviewer?.threadId);
         const reviewerRouting = await this.selectReviewer(reviewGateTasks, reviewThread ? chatgptThreadRequirements(this.options.reviewer?.requirements) : undefined);
-        const chatgptThreadDelivery = reviewThread ? {
-            kind: 'new-turn',
-            threadId: reviewThread.threadId,
-            threadSource: reviewThread.source,
-            requestId: `${job.id}:${id}:${headSha}`,
-            jobId: job.id,
-            prNumber: reviewPrNumber,
-            reviewHeadSha: headSha,
-            projectId: reviewerRouting.candidate.routing.projectId ?? null,
-        } : undefined;
+        const chatgptThreadDelivery = prepareReviewerThreadDelivery(job, {
+            id, agentName: 'reviewer', reviewHeadSha: headSha, routing: reviewerRouting.candidate.routing,
+        }, this.options.reviewer?.threadId);
         const input = [
             `Job ID: ${job.id}`,
             `Review PR #${reviewPrNumber} at exactly head SHA ${headSha}.`,
@@ -165,7 +159,23 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         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 } }));
         return id;
     }
+    async projectedReviewHeadReady(job, headSha) {
+        // Local-first Jobs may expose a review-only GitHub PR. Once such a PR is
+        // bound, its projected head must match the authoritative local head before
+        // a reviewer is asked to review that immutable PR identity.
+        if (!job.externalPrNumber || job.externalPrNumber <= 0 || !this.store.pullRequestHead)
+            return true;
+        try {
+            const projected = await this.store.pullRequestHead();
+            return projected?.sha === headSha;
+        }
+        catch {
+            return false;
+        }
+    }
     async ensureFinalReview(job, headSha) {
+        if (headSha && !(await this.projectedReviewHeadReady(job, headSha)))
+            return;
         let reviewTaskId = null;
         const decision = await dispatchReviewLifecycle(job.review?.outcome, 'reconcile', this.reviewFacts(job, headSha), async (actionId) => {
             if (actionId !== 'review.create')
@@ -239,15 +249,17 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         };
     }
     async routeTaskForExecution(job, task) {
-        if (task.routing)
+        const implementationThread = resolveImplementationTaskThreadDestination(job, task);
+        const reviewerThread = task.agentName === 'reviewer' ? resolveReviewerThreadDestination(job, this.options.reviewer?.threadId) : null;
+        if (task.routing && !((implementationThread || reviewerThread) && task.adapter !== 'chatgpt'))
             return { task, routed: false };
         if (!task.output || task.adapter === 'orchestrator')
             return { task, routed: false };
         const usage = this.options.usageSnapshotProvider ? await this.options.usageSnapshotProvider() : undefined;
         const registered = await this.store.listAgents();
-        const candidates = workerCandidates(this.options.adapters, registered, usage);
+        const candidates = workerCandidates(this.options.adapters, registered, usage).filter(candidate => (implementationThread || reviewerThread) ? candidate.adapter === 'chatgpt' : true);
         const runtimeSummary = this.options.runtimeSummaryProvider?.();
-        const requirements = task.workerRequirements ?? { capabilities: [] };
+        const requirements = (implementationThread || reviewerThread) ? chatgptThreadRequirements(task.workerRequirements) : (task.workerRequirements ?? { capabilities: [] });
         const taskFacts = {
             job: {
                 id: job.id, title: job.title, objective: job.objective ?? null,
@@ -313,9 +325,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             return { applied: false, reconcile: false, reason: event.type + '.stale' };
         // Planner-created reviewer tasks predate the final-review Job gate. Bind
         // their first trustworthy review event to PENDING before dispatching it.
-        if (!job.review && task.planningDecisionId) {
-            job.review = { outcome: 'pending', headSha, taskId: task.id, evidence: null, updatedAt: event.timestamp || new Date().toISOString() };
-        }
+        const initialReviewOutcome = !job.review && task.planningDecisionId ? 'pending' : job.review?.outcome;
         const taskDecision = this.store.mutateJob
             ? dispatchTaskLifecycleSync(structuredClone(task), event.type)
             : tryTransitionTaskEvent(task, event.type);
@@ -332,7 +342,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         }
         let needsReconcile = false;
         let pendingFixTask = null;
-        const reviewDecision = await dispatchReviewLifecycle(job.review?.outcome, event.type, { autoMerge: job.autoMerge !== false }, async (actionId) => {
+        const reviewDecision = await dispatchReviewLifecycle(initialReviewOutcome, event.type, { autoMerge: job.autoMerge !== false }, async (actionId) => {
             if (actionId === 'review.createFix') {
                 needsReconcile = true;
                 const issues = normalizedEvidence.issues;
@@ -371,13 +381,22 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
                 const freshTask = current.tasks.find(item => item.id === task.id);
                 if (!freshTask || !reviewGenerationMatches(current, job, task, headSha))
                     return current;
-                const freshDecision = tryTransitionTaskEvent(freshTask, event.type);
+                const candidate = structuredClone(freshTask);
+                const freshDecision = tryTransitionTaskEvent(candidate, event.type);
                 if (!freshDecision.accepted || !freshDecision.target)
                     return current;
                 if (freshDecision.target !== 'RUNNING') {
-                    if (!this.finalizeReviewExecution(job.id, freshTask, event, false))
-                        return current;
+                    // Capture the execution generation before finalization clears it.
+                    // Post-commit cleanup must cancel the matching live watchdog.
                     terminalExecutionId = freshTask.executionId;
+                    if (!this.finalizeReviewExecution(job.id, candidate, event, false))
+                        return current;
+                }
+                Object.assign(freshTask, candidate);
+                // Bind the first Planner review only after the generation fence has
+                // checked the unmodified outer snapshot and authoritative SQLite state.
+                if (!current.review && freshTask.planningDecisionId) {
+                    current.review = { outcome: 'pending', headSha, taskId: freshTask.id, evidence: null, updatedAt: reviewUpdatedAt };
                 }
                 freshTask.error = null;
                 if (freshDecision.target !== 'RUNNING')

package/dist/reconciler-runtime.js

@@ -93,8 +93,6 @@ export class ReconcilerRuntimeBase {
             const result = await this.applyTerminalEvent(event);
             if (event.type !== 'task.failed' || event.source?.watchdog !== true || event.data?.workflowEvent !== 'watchdog.failed' || result.reconcile)
                 return result;
-            // The watchdog has already committed FAILED. The graph owns the recovery
-            // action; this correlated event wakes the graph evaluation, not a retry.
             const durable = (await this.store.load(event.job_id)).tasks.find(task => task.id === event.task_id);
             return durable?.state === 'FAILED' && durable.executionHistory?.some(history => history.id === event.data?.executionId)
                 ? { applied: true, reconcile: true, reason: 'watchdog.failure-fact' } : result;
@@ -199,7 +197,6 @@ export class ReconcilerRuntimeBase {
     }
     async markWorkerStarted(event) {
         const live = this.live.get(event.task_id);
-        // Event timestamps are worker-authored and may be wrong; exact execution identity is authoritative.
         const transition = await this.taskTransitions.apply(event.job_id, event.task_id, 'task.started', {
             eligible: (job, task) => {
                 if (!task.executionId || eventSourceId(event) !== executionEventSource(job.id, task.id, task.executionId))
@@ -258,6 +255,10 @@ export class ReconcilerRuntimeBase {
         return true;
     }
     async failLaunch(jobId, taskId, executionId, message, phase = 'launch') {
+        const failureReason = phase === 'start-ack' ? 'worker_start_timeout'
+            : /BROWSER_WORKSPACE_UNAVAILABLE|browser-workspace runtime dependency unavailable|browser-workspace session start returned no session_id|no close frame received or sent/i.test(message)
+                ? 'browser_workspace_unavailable'
+                : undefined;
         const claim = executionId ?? `${jobId}:${taskId}`;
         if (this.launchFailureClaims.has(claim))
             return;
@@ -270,7 +271,7 @@ export class ReconcilerRuntimeBase {
             mutate: (_job, task) => {
                 this.clearExecution(task.id, executionId);
                 task.error = `Worker ${phase} failed: ${message}`;
-                task.failureReason = phase === 'start-ack' ? 'worker_start_timeout' : undefined;
+                task.failureReason = failureReason;
                 task.leaseOwner = null;
                 task.leaseExpiresAt = null;
             },
@@ -281,12 +282,24 @@ export class ReconcilerRuntimeBase {
             await this.emit(eventFor(jobId, taskId, transition.task.parentTaskId, 'task.process.delivery_failed', 'failed', `Worker ${phase} reported after lifecycle moved to ${transition.from}: ${message}`, 'orchestrator', { phase, authoritative: false, executionId, workflowEvent }, { agent: 'relay', component: 'agents-relay' }));
             return;
         }
-        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? `Worker ${phase} failed: ${message}`, 'user', { phase, reason: transition.task.failureReason, workflowEvent }, { agent: 'relay', component: 'agents-relay', watchdog: true });
+        let runtimeRetry = null;
+        if (failureReason === 'browser_workspace_unavailable' && transition.task.attempt < transition.task.maxAttempts) {
+            const current = (await this.store.load(jobId)).tasks.find(task => task.id === taskId);
+            if (current?.state === 'FAILED' && current.failureReason === failureReason && current.attempt === transition.task.attempt) {
+                await applyTaskRetryAction(current);
+                current.routing = undefined;
+                current.workerSelection = undefined;
+                await this.store.saveTask(current);
+                runtimeRetry = current;
+            }
+        }
+        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? `Worker ${phase} failed: ${message}`, 'user', { phase, reason: failureReason, workflowEvent }, { agent: 'relay', component: 'agents-relay', watchdog: true });
         this.detach(this.emit(event), jobId, taskId, 'worker failure event');
-        // failLaunch already committed the authoritative FAILED state. The emitted
-        // task.failed observation may be ignored as a duplicate, so explicitly wake
-        // graph reconciliation from the durable failure fact. This is required for
-        // automatic Troubleshooter recovery, including reviewer start-ack failures.
+        if (runtimeRetry) {
+            this.detach(this.emit(eventFor(jobId, taskId, runtimeRetry.parentTaskId, 'task.runtime_retry', 'queued', 'Browser Workspace runtime unavailable; retrying the same Task', 'orchestrator', { previousFailure: failureReason, attempt: runtimeRetry.attempt, maxAttempts: runtimeRetry.maxAttempts })), jobId, taskId, 'runtime retry event');
+            this.detach(this.eventCoordinator.accept({ jobId, reason: 'browser-workspace-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) {
@@ -297,9 +310,6 @@ export class ReconcilerRuntimeBase {
         }
         const job = await this.store.load(jobId);
         const task = job.tasks.find(item => item.id === taskId);
-        // Async transport settlement is an independent, non-authoritative observation.
-        // A worker terminal event may already have claimed the Task; do not suppress
-        // transport-exit evidence merely because business completion won the race.
         if (!task)
             return;
         const correlated = task.executionId === executionId || task.executionHistory?.some(item => item.id === executionId);
@@ -338,9 +348,6 @@ export class ReconcilerRuntimeBase {
             return;
         }
         let reroutedTask = null;
-        // Provider quota failures are recoverable. Commit the retry + route exclusion
-        // before publishing task.failed so event-driven reconciliation can never see
-        // an intermediate FAILED state and spawn a Troubleshooter for quota exhaustion.
         if (reroutableWorkerRejections.has(failureReason) && transition.task.attempt < transition.task.maxAttempts) {
             const current = (await this.store.load(jobId)).tasks.find(task => task.id === taskId);
             if (current?.state === 'FAILED' && current.failureReason === failureReason && current.attempt === transition.task.attempt) {
@@ -353,7 +360,7 @@ export class ReconcilerRuntimeBase {
                                 provider: failedRoute.provider,
                                 model: failedRoute.model,
                                 ...(failedRoute.profile ? { profile: failedRoute.profile } : {}),
-                                reason: 'rate_limit_exceeded',
+                                reason: failureReason,
                                 at: new Date().toISOString(),
                             }];
                 }
@@ -377,17 +384,12 @@ export class ReconcilerRuntimeBase {
             eligible: (_job, task) => {
                 if (!['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
                     return false;
-                // Reviewer business terminal state is owned by review.approved / review.changes_required / review.blocked.
-                // A generic task.completed may arrive before the review decision and must not consume the execution generation.
                 if (task.agentName === 'reviewer' && event.type === 'task.completed')
                     return false;
                 const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
                 if (!trustedInternal && modelBacked && !this.isCorrelatedWorkerEvent(task, event)) {
                     const eventExecutionId = executionIdFromSource(eventSourceId(event), _job.id, task.id);
                     const prior = eventExecutionId ? task.executionHistory?.find(item => item.id === eventExecutionId) : undefined;
-                    // A duplicate launch can leave one worker orphaned after another worker
-                    // has already produced the terminal fact. Accept only a known execution
-                    // from the same durable attempt. A prior retry attempt cannot complete a newer generation.
                     if (!prior || prior.attempt !== task.attempt)
                         return false;
                 }

package/dist/reconciler.js

@@ -8,12 +8,12 @@ import { dependencyReady, schedule, transitionTaskEvent } from './scheduler.js';
 import { applyTaskRetryAction } from './task-actions.js';
 import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
-import { createPlanRound, materializePlannerChild, pendingPlan } from './planner.js';
+import { createPlanRound, materializePlannerChild, pendingPlan, validatePlannerResolutionMaterialization } from './planner.js';
 import { retryPendingPlannerUnblocks } from './planner-runtime.js';
 import { dispatchPlannerOrchestration, plannerOrchestrationFacts } from './workflow/planner-orchestration-v2.js';
 import { resolveExecutionContext } from './execution-context.js';
 import { ReconcilerReviewBase } from './reconciler-review.js';
-import { recordThreadDelivery } from './reviewer-thread.js';
+import { recordThreadDelivery, resolveImplementationTaskThreadDestination, prepareReviewerThreadDelivery, resolveReviewerThreadDestination } from './reviewer-thread.js';
 import { executeManualPlan } from './manual-plan.js';
 import { executionEventSource, withExecutionBoundary } from './reconciler-runtime.js';
 export { executionEventSource } from './reconciler-runtime.js';
@@ -23,6 +23,7 @@ import { taskUsesCanonicalProjectRun } from './workspace.js';
 import { cleanupMergedJobWorktree } from './job-worktree-cleanup.js';
 import { jobHasActiveExecution } from './job-execution-slot.js';
 import { managedWorkerInput } from './managed-worker-input.js';
+import { attachResolutionOwnership } from './workflow/task-resolution.js';
 export { managedWorkerInput } from './managed-worker-input.js';
 import { recoverExpiredExecutions, recoverStartupOrphans as recoverStartupExecutionOrphans } from './execution-recovery.js';
 import { dispatchJobReconcile } from './workflow/job-reconcile-v2.js';
@@ -77,7 +78,6 @@ export class Reconciler extends ReconcilerReviewBase {
             const previousState = job.state;
             const lifecycleFingerprint = (value) => `${value.state}|${value.tasks.map(task => `${task.id}:${task.state}`).join(',')}`;
             const beforeFingerprint = lifecycleFingerprint(job);
-            // GitHub state is audit-only and never participates in workflow decisions.
             const headSha = await this.currentHeadSha(job);
             if (headSha && job.headSha !== headSha) {
                 if (job.localMerge && job.localMerge.status !== 'succeeded') {
@@ -116,8 +116,6 @@ export class Reconciler extends ReconcilerReviewBase {
             }
             {
                 const recoveryJob = await this.store.load(jobId);
-                // A failed recovery worker is itself recoverable: retry the SAME Task
-                // within its budget. No recursive Troubleshooter is generated.
                 for (const recovery of recoveryJob.tasks) {
                     if (recovery.agentName !== 'troubleshooter' || recovery.state !== 'FAILED' || recovery.attempt >= recovery.maxAttempts)
                         continue;
@@ -275,18 +273,19 @@ export class Reconciler extends ReconcilerReviewBase {
     async recoverPlannerChildren(job) {
         for (const plan of (job.plans ?? []).filter(item => item.status === 'SUCCEEDED' && item.plannerResult)) {
             const executionContext = await this.plannerContext(job, plan);
+            validatePlannerResolutionMaterialization(job.tasks, plan.plannerResult.next_tasks);
             const children = plan.plannerResult.next_tasks.map(spec => materializePlannerChild(job, plan, spec, executionContext));
             for (const child of children) {
                 const existing = job.tasks.find(item => item.id === child.id);
                 if (existing)
                     continue;
+                const spec = plan.plannerResult.next_tasks.find(item => item.id === child.id);
+                if (spec?.resolution)
+                    await this.store.saveTask(attachResolutionOwnership(job, child, spec.resolution, 'planner'));
                 await this.store.appendTask(child);
                 job.tasks.push(child);
             }
         }
-        // Only legacy successful Planner Tasks need execution context. Ordinary
-        // failed work must not fetch a GitHub PR head merely to check for legacy
-        // planner records; offline Troubleshooter recovery must remain runnable.
         const historicalPlanners = job.tasks.filter(task => task.kind === 'planner' && task.state === 'SUCCEEDED' && task.plannerResult);
         if (historicalPlanners.length === 0)
             return;
@@ -303,6 +302,9 @@ export class Reconciler extends ReconcilerReviewBase {
             const children = result.next_tasks.map(spec => materializePlannerChild(job, plan, spec, executionContext));
             for (const child of children)
                 if (!job.tasks.some(item => item.id === child.id)) {
+                    const spec = result.next_tasks.find(item => item.id === child.id);
+                    if (spec?.resolution)
+                        await this.store.saveTask(attachResolutionOwnership(job, child, spec.resolution, 'planner'));
                     await this.store.appendTask(child);
                     job.tasks.push(child);
                 }
@@ -346,7 +348,8 @@ export class Reconciler extends ReconcilerReviewBase {
                 return;
             if (freshTask.agentName === 'reviewer' && freshTask.planningDecisionId && freshTask.dependencies.length)
                 await bindPlannedReviewHead(this.store, freshTask, await this.currentHeadSha(freshJob));
-            if (!freshTask.routing && freshTask.adapter !== 'orchestrator') {
+            const implementationThread = resolveImplementationTaskThreadDestination(freshJob, freshTask);
+            if ((!freshTask.routing || ((implementationThread || (freshTask.agentName === 'reviewer' && resolveReviewerThreadDestination(freshJob, this.options.reviewer?.threadId))) && freshTask.adapter !== 'chatgpt')) && freshTask.adapter !== 'orchestrator') {
                 freshTask = (await this.routeTaskForExecution(freshJob, freshTask)).task;
             }
             if (['codex', 'chatgpt'].includes(freshTask.adapter) && !freshTask.routing) {
@@ -363,6 +366,16 @@ export class Reconciler extends ReconcilerReviewBase {
                     attempt: freshTask.attempt,
                     startedAt: new Date(startedAt).toISOString(),
                 }].slice(-8);
+            if (freshTask.agentName === 'reviewer')
+                freshTask.chatgptThreadDelivery = prepareReviewerThreadDelivery(freshJob, freshTask, this.options.reviewer?.threadId);
+            if (implementationThread && freshTask.adapter === 'chatgpt') {
+                freshTask.chatgptThreadDelivery = {
+                    kind: 'new-turn', threadId: implementationThread, threadSource: 'implementation',
+                    requestId: `${freshJob.id}:${freshTask.id}:${freshTask.executionId}`,
+                    jobId: freshJob.id, prNumber: freshJob.prNumber, executionId: freshTask.executionId,
+                    projectId: freshTask.routing?.projectId ?? null, deliveredAt: null,
+                };
+            }
             if (this.store.mutateJob) {
                 let claimed;
                 await this.store.mutateJob(job.id, current => {
@@ -370,8 +383,6 @@ export class Reconciler extends ReconcilerReviewBase {
                     if (!durable || durable.state !== 'QUEUED' || durable.executionId !== null
                         || !dependencyReady(durable, new Map(current.tasks.map(item => [item.id, item]))))
                         return current;
-                    // Routing is a pre-claim fact; copy only that fact into the fresh
-                    // authoritative snapshot, then claim the generation atomically.
                     if (freshTask.routing)
                         durable.routing = structuredClone(freshTask.routing);
                     if (freshTask.workerSelection)
@@ -383,6 +394,17 @@ export class Reconciler extends ReconcilerReviewBase {
                     durable.executionHistory = [...(durable.executionHistory ?? []), {
                             id: durable.executionId, attempt: durable.attempt, startedAt: new Date(startedAt).toISOString(),
                         }].slice(-8);
+                    const implementationThread = resolveImplementationTaskThreadDestination(current, durable);
+                    if (durable.agentName === 'reviewer')
+                        durable.chatgptThreadDelivery = prepareReviewerThreadDelivery(current, { ...durable, routing: freshTask.routing }, this.options.reviewer?.threadId);
+                    if (implementationThread && durable.adapter === 'chatgpt') {
+                        durable.chatgptThreadDelivery = {
+                            kind: 'new-turn', threadId: implementationThread, threadSource: 'implementation',
+                            requestId: `${current.id}:${durable.id}:${durable.executionId}`,
+                            jobId: current.id, prNumber: current.prNumber, executionId: durable.executionId,
+                            projectId: durable.routing?.projectId ?? null, deliveredAt: null,
+                        };
+                    }
                     claimed = structuredClone(durable);
                     return current;
                 });
@@ -429,10 +451,17 @@ export class Reconciler extends ReconcilerReviewBase {
         const startAckSetup = task.adapter === 'chatgpt' ? await this.startAck(job.id, task.id, sourceId, Date.now(), this.options.startAckTimeoutMs ?? chatGptStartAckTimeoutMs(task.timeoutMs)) : null;
         const closePolicy = task.chatgptTabClosePolicy ?? this.options.chatgptTabClosePolicy ?? adapter.tabClosePolicy ?? 'after-start';
         const terminalWait = task.adapter === 'chatgpt' && closePolicy === 'after-terminal' ? this.terminalWait(task.id, durableExecutionId, startedAt - 1) : null;
-        // Consume E2E injection before execution: a retry will not repeat it.
-        // Production repositories ignore the option entirely.
         const declaration = authorizedInjection(job.repository, task.testInjection);
-        const testInjection = declaration && ((task.adapter === 'codex' && declaration.method === 'worker.codex.launch') || (task.adapter === 'chatgpt' && declaration.method === 'browserWorkspace.command')) ? declaration : undefined;
+        if (task.testInjection && !declaration) {
+            await this.failLaunch(job.id, task.id, durableExecutionId, `E2E test injection refused for repository ${job.repository}; configure E2E_REPO on relayd`, 'delivery');
+            return;
+        }
+        const workerCheckpoint = declaration?.method === 'worker.codex.launch' || declaration?.method === 'browserWorkspace.command';
+        const testInjection = workerCheckpoint && ((task.adapter === 'codex' && declaration.method === 'worker.codex.launch') || (task.adapter === 'chatgpt' && declaration.method === 'browserWorkspace.command')) ? declaration : undefined;
+        if (workerCheckpoint && !testInjection) {
+            await this.failLaunch(job.id, task.id, durableExecutionId, `E2E test injection ${declaration.method} is incompatible with adapter ${task.adapter}`, 'delivery');
+            return;
+        }
         if (testInjection) {
             const durable = (await this.store.load(job.id)).tasks.find(item => item.id === task.id);
             if (!durable || durable.executionId !== durableExecutionId)

package/dist/relayd-control.js

@@ -1,3 +1,4 @@
+import { normalizeThreadId } from './reviewer-thread.js';
 export function createWorkspaceControl(deps) {
     const { client, trusted, noGitHub, repositories, refreshAll, requireLocalJobBinding, makeReconciler, concurrency, pool, bus, isEffectivelyBlocked, unblockAutonomousTasks, unblockTask, publishTaskUnblocked, dispatchTaskAction, registerBlockerDependency, discoverAgents, ensureManagedGitHubJob } = deps;
     const workspaceControl = async (body) => {
@@ -27,6 +28,7 @@ export function createWorkspaceControl(deps) {
                 body: typeof options.body === 'string' ? options.body : undefined,
                 reviewerThreadId: typeof options.reviewerThreadId === 'string' ? options.reviewerThreadId : undefined,
                 creatorThreadId: typeof options.creatorThreadId === 'string' ? options.creatorThreadId : undefined,
+                implementationThreadId: typeof options.implementationThreadId === 'string' ? options.implementationThreadId : undefined,
                 noGitHub,
                 localMergeSource: typeof options.localMergeSource === 'string' ? options.localMergeSource : undefined,
                 localMergeTarget: typeof options.localMergeTarget === 'string' ? options.localMergeTarget : undefined,
@@ -55,10 +57,16 @@ export function createWorkspaceControl(deps) {
         const job = await store.load(jobId);
         if (command === 'job.update') {
             const patch = (body.patch && typeof body.patch === 'object' ? body.patch : {});
-            const mutable = ['title', 'objective', 'projectPath', 'priority', 'executionMode', 'schedule', 'tag', 'autoMerge', 'reviewEnabled', 'reviewerThreadId', 'creatorThreadId', 'continuation', 'localMerge'];
+            const mutable = ['title', 'objective', 'projectPath', 'priority', 'executionMode', 'schedule', 'tag', 'autoMerge', 'reviewEnabled', 'reviewerThreadId', 'creatorThreadId', 'implementationThreadId', 'continuation', 'localMerge'];
             for (const key of mutable)
-                if (Object.prototype.hasOwnProperty.call(patch, key))
-                    job[key] = patch[key];
+                if (Object.prototype.hasOwnProperty.call(patch, key)) {
+                    const value = patch[key];
+                    if (['reviewerThreadId', 'creatorThreadId', 'implementationThreadId'].includes(key)) {
+                        job[key] = value === undefined || value === null ? undefined : normalizeThreadId(value, `Job ${key}`);
+                    }
+                    else
+                        job[key] = value;
+                }
             job.updatedAt = new Date().toISOString();
             await store.saveJob(job);
             await refreshAll();
@@ -132,6 +140,9 @@ export function createWorkspaceControl(deps) {
             const dependentTaskId = typeof body.dependentTaskId === 'string' ? body.dependentTaskId : '';
             const dependent = await requireLocalJobBinding(dependentJobId);
             const relation = await registerBlockerDependency({ blockerStore: store, blockerJobId: jobId, dependentStore: dependent.store, dependentJobId, dependentTaskId, resolutionMode: body.resolutionMode === 'verified' ? 'verified' : 'merge' });
+            // Registering a blocker is itself runnable-work creation. Wake the blocker
+            // Job immediately instead of waiting for inventory polling/stale rescue.
+            await pool.reconcileLocalJob(jobId, 'control.blocker.add');
             await refreshAll();
             return relation;
         }

package/dist/relayd.js

@@ -18,6 +18,7 @@ import { createJobIdRegistryResolver } from './local-job-registry.js';
 import { projectAuthoritativeLocalMerge } from './local-merge-projection.js';
 import { archiveDisplayPullRequest } from './github-pr-archive.js';
 import { orderGitHubBindingCandidates } from './github-binding-order.js';
+import { authoritativeBranchPushArgs } from './github-branch-projection.js';
 import { githubAuthContext } from './github-auth.js';
 import { DisabledGitHubClient, noGitHubMode } from './no-github.js';
 import { basename } from 'node:path';
@@ -251,7 +252,21 @@ export async function runDaemon(argv) {
                 const sourceSha = await gitText(canonical, ['rev-parse', '--verify', sourceRef]);
                 const facts = await relay.loadPullRequestFacts();
                 if (facts?.head?.sha !== sourceSha) {
-                    await gitText(canonical, ['push', 'origin', `${branch}:${branch}`]);
+                    await gitText(canonical, ['fetch', '--no-tags', 'origin',
+                        '+refs/heads/main:refs/remotes/origin/main']);
+                    await gitText(canonical, ['fetch', '--no-tags', 'origin',
+                        `+refs/heads/${branch}:refs/remotes/origin/${branch}`]).catch(() => '');
+                    const remoteRef = `refs/remotes/origin/${branch}`;
+                    const remoteHeadSha = await gitText(canonical, ['rev-parse', '--verify', remoteRef]).catch(() => '');
+                    const remoteTreeMatchesBase = remoteHeadSha
+                        ? await gitText(canonical, ['diff', '--quiet', 'refs/remotes/origin/main', remoteRef]).then(() => true, () => false)
+                        : false;
+                    await gitText(canonical, authoritativeBranchPushArgs({
+                        sourceRef,
+                        branch,
+                        remoteHeadSha: remoteHeadSha || null,
+                        remoteTreeMatchesBase,
+                    }));
                 }
                 let job = (await relay.loadJob(discovered.id)) ?? discovered;
                 let externalPrNumber = job.externalPrNumber ?? (job.prNumber > 0 ? job.prNumber : 0);

package/dist/reviewer-thread.js

@@ -1,4 +1,10 @@
 import { arg, hasArg } from './cli-support.js';
+export function resolveImplementationThreadDestination(job) {
+    return job.implementationThreadId ? normalizeThreadId(job.implementationThreadId, 'Job implementation thread ID') ?? null : null;
+}
+export function resolveImplementationTaskThreadDestination(job, task) {
+    return task.agentName === 'implementation' ? resolveImplementationThreadDestination(job) : null;
+}
 export function normalizeThreadId(value, label = 'thread ID') {
     if (value === undefined || value === null)
         return undefined;
@@ -21,6 +27,27 @@ export function resolveReviewerThreadDestination(job, override) {
     const creatorThreadId = job.creatorThreadId ? normalizeThreadId(job.creatorThreadId, 'Job creator thread ID') : undefined;
     return creatorThreadId ? { threadId: creatorThreadId, source: 'creator' } : null;
 }
+export function prepareReviewerThreadDelivery(job, task, override) {
+    if (task.agentName !== 'reviewer')
+        return undefined;
+    const destination = resolveReviewerThreadDestination(job, override);
+    if (!destination)
+        return undefined;
+    const existing = task.chatgptThreadDelivery;
+    if (existing?.deliveredAt) {
+        if (existing.threadId !== destination.threadId)
+            throw new Error('Cannot redirect an already delivered reviewer task');
+        return existing;
+    }
+    return {
+        kind: 'new-turn', threadId: destination.threadId, threadSource: destination.source,
+        requestId: existing?.requestId ?? `${job.id}:${task.id}:${task.reviewHeadSha ?? job.headSha ?? 'review'}`,
+        jobId: job.id, prNumber: job.externalPrNumber && job.externalPrNumber > 0 ? job.externalPrNumber : job.prNumber,
+        ...(task.reviewHeadSha ? { reviewHeadSha: task.reviewHeadSha } : {}),
+        projectId: task.routing?.projectId ?? null,
+        ...(existing?.executionId ? { executionId: existing.executionId } : {}),
+    };
+}
 export function chatgptThreadRequirements(configured) {
     const base = configured ?? { capabilities: ['model'] };
     const capabilities = new Set([...base.capabilities, 'model', 'chatgpt', 'browser-workspace']);
@@ -35,11 +62,23 @@ export function runtimeReviewer(args = []) {
 }
 export async function recordThreadDelivery(store, jobId, taskId, executionId, workerTask) {
     const delivery = workerTask.chatgptThreadDelivery;
-    if (!delivery || delivery.deliveredAt)
+    if (!delivery || delivery.deliveredAt || (delivery.executionId !== undefined && delivery.executionId !== executionId))
+        return;
+    const mark = (job) => {
+        const current = job.tasks.find(item => item.id === taskId);
+        if (!current || current.executionId !== executionId || current.state !== 'RUNNING' || !current.chatgptThreadDelivery
+            || current.chatgptThreadDelivery.requestId !== delivery.requestId || current.chatgptThreadDelivery.deliveredAt)
+            return job;
+        current.chatgptThreadDelivery = { ...current.chatgptThreadDelivery, executionId, deliveredAt: new Date().toISOString() };
+        return job;
+    };
+    if (store.mutateJob) {
+        await store.mutateJob(jobId, mark);
         return;
+    }
     const current = (await store.load(jobId)).tasks.find(item => item.id === taskId);
-    if (current?.executionId !== executionId || current.state !== 'RUNNING' || !current.chatgptThreadDelivery)
+    if (!current || current.executionId !== executionId || current.state !== 'RUNNING' || !current.chatgptThreadDelivery || current.chatgptThreadDelivery.requestId !== delivery.requestId || current.chatgptThreadDelivery.deliveredAt)
         return;
-    current.chatgptThreadDelivery = { ...current.chatgptThreadDelivery, deliveredAt: new Date().toISOString() };
+    current.chatgptThreadDelivery = { ...current.chatgptThreadDelivery, executionId, deliveredAt: new Date().toISOString() };
     await store.saveTask(current);
 }

package/dist/task-actions.js

@@ -1,5 +1,6 @@
 import { extendRetryBudget, transitionTaskEvent, tryTransitionTaskEvent } from './scheduler.js';
 import { selectRelatedTaskMutations } from './workflow/task-action-policy.js';
+import { dispatchTaskResolutionSync, materializeResolution } 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';
@@ -161,8 +162,14 @@ export async function dispatchTaskAction(store, request) {
                     throw new Error(`task recover requires an active Troubleshooter recovery for ${task.id}`);
             }
             const relatedMutations = request.id === TASK_RECOVER_ACTION ? [] : selectRelatedTaskMutations(current, task, request.id);
-            if (request.id === TASK_RETRY_ACTION || request.id === TASK_RECOVER_ACTION)
+            if (request.id === TASK_RETRY_ACTION)
                 applyTaskRetrySnapshot(task, { extendBudget: true });
+            else if (request.id === TASK_RECOVER_ACTION) {
+                const proposal = { path: 'exact_original_retry', targetTaskId: task.id, rootCause: task.failureReason ?? task.error ?? 'durable failure', solution: `Recover exact original Task via ${request.recoveryTaskId}` };
+                const decision = dispatchTaskResolutionSync(task, proposal, 'troubleshooter', { activateRecovery: () => { applyTaskRetrySnapshot(task, { extendBudget: true }); task.resolution = { ...materializeResolution(task, proposal, 'troubleshooter'), state: 'resolved' }; } });
+                if (!decision.accepted)
+                    throw new Error(`Task resolution graph rejected exact-original recovery for ${task.id}`);
+            }
             else if (request.id === TASK_CANCEL_ACTION)
                 cancelTaskSnapshot(task);
             for (const mutation of relatedMutations) {
@@ -189,7 +196,10 @@ 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}`);
-        await applyTaskRetryAction(task, { extendBudget: true });
+        const proposal = { path: 'exact_original_retry', targetTaskId: task.id, rootCause: task.failureReason ?? task.error ?? 'durable failure', solution: `Recover exact original Task via ${request.recoveryTaskId}` };
+        const decision = dispatchTaskResolutionSync(task, proposal, 'troubleshooter', { activateRecovery: () => { applyTaskRetrySnapshot(task, { extendBudget: true }); task.resolution = { ...materializeResolution(task, proposal, 'troubleshooter'), state: 'resolved' }; } });
+        if (!decision.accepted)
+            throw new Error(`Task resolution graph rejected exact-original recovery for ${task.id}`);
     }
     else if (request.id === TASK_UNBLOCK_RETRY_ACTION)
         await applyTaskUnblockRetryAction(task);

package/dist/troubleshooter.js

@@ -26,7 +26,7 @@ Retrieve this task's lifecycle event history before classifying the root cause o
 GET http://127.0.0.1:8787/api/events?job=${encodeURIComponent(job.id)}&task=${encodeURIComponent(task.id)}&limit=200
 Inspect event order, type/status, source, data/phase, duplicate events, missing expected lifecycle events, late events, and execution identifiers. If the event stream points to delivery/runtime failure, inspect the corresponding Relay/worker/tool logs too. Do not treat the final task.error string as the complete root cause.
 
-Follow the selected Troubleshooter agent contract. Diagnose root cause from durable task state + event history + relevant runtime logs before retry. The final task.error string alone is never sufficient. Classify the evidence as model/provider/runtime, worker/tool/infrastructure, semantic task failure, or timeout/unknown. Only model/provider/runtime evidence may call the narrow model re-decision action; that action gathers fresh usage, reloads current policy, updates this exact Task's routing, and does not retry it. Troubleshooter must then reactivate/retry this exact original task and verify progress. Use the dedicated agents-relay task recover path with --task-id ${task.id} and --recovery-task-id ${troubleshooterTaskId(task)}; 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 the blocker is a shared worker/runtime/tool defect, create and directly complete a P0/self-job in the owning repository, including required release/deploy verification. If diagnosis suggests a genuine human/external blocker, do not publish task.blocked directly and do not implement the result branch procedurally. Call agents-relay escalation with the original intent, blocker, and relevant context. Pass any caller-defined notification plan through --on-needs-user/--on-needs-user-file; do not hard-code a channel. The canonical escalation graph invokes Neo escalation and owns the resolved/failed/needs_user branch; follow its selected outcome. Retry this exact original task only after the blocker is removed, reconcile the original job, and verify durable progress.`;
+Follow the selected Troubleshooter agent contract. Diagnose root cause from durable task state + event history + relevant runtime logs before retry. The final task.error string alone is never sufficient. Classify the evidence as model/provider/runtime, worker/tool/infrastructure, semantic task failure, or timeout/unknown. Select exactly one graph-enabled resolution path: exact_original_retry, same_job_dependency, blocker_job_dependency (with merge or verified mode), escalation_gate, or cancel_supersede. Only model/provider/runtime evidence may call the narrow model re-decision action; that action gathers fresh usage, reloads current policy, updates this exact Task's routing, and does not retry it. Troubleshooter must then reactivate/retry this exact original task and verify progress. Use the dedicated agents-relay task recover path with --task-id ${task.id} and --recovery-task-id ${troubleshooterTaskId(task)}; 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; no replacement_task action exists. If the blocker is a shared worker/runtime/tool defect, create and directly complete a P0/self-job in the owning repository, including required release/deploy verification. If diagnosis suggests a genuine human/external blocker, do not publish task.blocked directly and do not implement the result branch procedurally. Call agents-relay escalation with the original intent, blocker, and relevant context. Pass any caller-defined notification plan through --on-needs-user/--on-needs-user-file; do not hard-code a channel. The canonical escalation graph invokes Neo escalation and owns the resolved/failed/needs_user branch; follow its 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;

package/dist/workflow/orchestrator-rescue.js

@@ -13,7 +13,9 @@ export const orchestratorRescueV2 = new GraphRuntime(source, {
 export function orchestratorRescueFacts(task, now) {
     const createdAt = Date.parse(task.createdAt);
     const oldEnough = Number.isFinite(createdAt) && now - createdAt >= STALE_ORCHESTRATOR_TASK_MS;
-    return { rescuable: task.kind !== 'planner' && task.adapter === 'orchestrator' && task.state === 'QUEUED' && task.executionId === null && oldEnough };
+    const urgentRepair = task.priority === 'P0' && task.agentName === 'troubleshooter';
+    return { rescuable: task.kind !== 'planner' && task.adapter === 'orchestrator' && task.state === 'QUEUED'
+            && task.executionId === null && (oldEnough || urgentRepair) };
 }
 export function decideOrchestratorRescue(task, now) {
     return dispatchWorkflowGraphSync(orchestratorRescueV2, {
@@ -28,8 +30,10 @@ export function applyOrchestratorRescue(task, now) {
     const ageMs = now - Date.parse(task.createdAt);
     if (!rescued)
         return { rescued: false, ageMs };
-    task.adapter = 'chatgpt';
-    task.workerRequirements = { capabilities: [...task.capabilities], runtime: 'chatgpt' };
+    const urgentRepair = task.priority === 'P0' && task.agentName === 'troubleshooter';
+    task.adapter = urgentRepair ? 'codex' : 'chatgpt';
+    task.workerRequirements = { capabilities: [...task.capabilities, ...(urgentRepair ? ['local_repo'] : [])],
+        runtime: urgentRepair ? 'codex' : 'chatgpt' };
     task.workerSelection = undefined;
     task.routing = undefined;
     task.timeoutMs = 0;

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

@@ -6,7 +6,7 @@ const source = readFileSync(new URL('../../workflow/planner-orchestration.mmd',
 const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
 export const plannerOrchestrationV2 = new GraphRuntime(source, {
     states: new Set([
-        'idle', 'check_legacy_pending', 'check_recover', 'check_seed', 'check_planner',
+        'idle', 'check_legacy_pending', 'check_recover', 'check_seed', 'check_planner', 'check_resolution_ownership',
         'check_blocked', 'check_work', 'check_materialized', 'check_objective', 'wait', 'recovered', 'created',
     ]),
     guards: {
@@ -15,6 +15,7 @@ export const plannerOrchestrationV2 = new GraphRuntime(source, {
         recoverablePendingPlan: boolGuard('recoverablePendingPlan'),
         hasSeedWork: boolGuard('hasSeedWork'),
         noActivePlanner: boolGuard('noActivePlanner'),
+        resolutionOwnedByTroubleshooter: boolGuard('resolutionOwnedByTroubleshooter'),
         noBlockedWork: boolGuard('noBlockedWork'),
         noActiveImplementation: boolGuard('noActiveImplementation'),
         continuationMaterialized: boolGuard('continuationMaterialized'),
@@ -27,10 +28,10 @@ export const plannerOrchestrationV2 = new GraphRuntime(source, {
     events: { 'planner.reconcile': { id: 'planner.reconcile' } },
 });
 export async function dispatchPlannerOrchestration(facts, executeAction) {
-    return dispatchWorkflowGraph(plannerOrchestrationV2, { initialState: 'idle', input: { transport: 'event', id: 'planner.reconcile', payload: {} }, durableFacts: facts, graphName: 'planner-orchestration', isTransientState: state => state.startsWith('check_'), maxSteps: 9, executeAction });
+    return dispatchWorkflowGraph(plannerOrchestrationV2, { initialState: 'idle', input: { transport: 'event', id: 'planner.reconcile', payload: {} }, durableFacts: facts, graphName: 'planner-orchestration', isTransientState: state => state.startsWith('check_'), maxSteps: 14, executeAction });
 }
 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: 9 });
+    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;
@@ -52,6 +53,7 @@ export function plannerOrchestrationFacts(job, recoverablePendingPlan) {
         noActivePlanner: !scopedPlans.some(plan => plan.status === 'PLANNING'),
         noBlockedWork: !scopedTasks.some(task => task.kind !== 'planner' && isEffectivelyBlocked(task)),
         noActiveImplementation: !scopedTasks.some(task => task.kind !== 'planner' && ['DRAFT', 'QUEUED', 'RUNNING'].includes(task.state)),
+        resolutionOwnedByTroubleshooter: scopedTasks.some(task => task.kind !== 'planner' && task.resolution?.owner === 'troubleshooter' && ['active', 'waiting'].includes(task.resolution.state)),
         continuationMaterialized: !(latestObjective === 'in_progress' && latestId && !job.tasks.some(task => task.kind !== 'planner' && task.planningDecisionId === latestId)),
         objectiveUnsatisfied: latestObjective !== 'satisfied',
     };

package/dist/workflow/task-resolution.js

@@ -0,0 +1,104 @@
+import { readFileSync } from 'node:fs';
+import { GraphRuntime } from './graph-v2.js';
+import { dispatchWorkflowGraph, dispatchWorkflowGraphSync } from './dispatcher.js';
+export const TASK_RESOLUTION_PATHS = [
+    'exact_original_retry', 'same_job_dependency', 'blocker_job_dependency', 'escalation_gate', 'cancel_supersede',
+];
+const source = readFileSync(new URL('../../workflow/task-resolution.mmd', import.meta.url), 'utf8');
+const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
+export const taskResolutionV2 = new GraphRuntime(source, {
+    states: new Set(['unresolved', 'check_owner', 'check_path', 'resolved']),
+    guards: {
+        recoveryOwnerAvailable: boolGuard('recoveryOwnerAvailable'), plannerOwnerAvailable: boolGuard('plannerOwnerAvailable'),
+        exactOriginalRetry: boolGuard('exactOriginalRetry'), sameJobDependency: boolGuard('sameJobDependency'),
+        blockerJobDependency: boolGuard('blockerJobDependency'), escalationGate: boolGuard('escalationGate'), genuinelyObsolete: boolGuard('genuinelyObsolete'),
+    },
+    actions: Object.fromEntries(['resolution.activateRecovery', 'resolution.attachSameJobDependency', 'resolution.registerBlockerDependency', 'resolution.createEscalationGate', 'resolution.cancelSupersede'].map(id => [id, { id }])),
+    events: { 'resolution.propose': { id: 'resolution.propose' } },
+});
+export function unresolvedTask(task) { return task.kind !== 'planner' && !['SUCCEEDED', 'CANCELLED'].includes(task.state); }
+export function validateResolutionProposal(job, original, proposal) {
+    if (!TASK_RESOLUTION_PATHS.includes(proposal.path))
+        throw new Error(`Unknown task resolution path ${proposal.path}`);
+    if (proposal.path === 'exact_original_retry' && original.state !== 'FAILED')
+        throw new Error('Exact-original retry requires a FAILED original Task');
+    if (proposal.path === 'same_job_dependency' && (!proposal.targetTaskId || !job.tasks.some(task => task.id === proposal.targetTaskId && task.jobId === job.id)))
+        throw new Error('Same-Job dependency resolution requires an existing target Task in the same Job');
+    if (proposal.path === 'blocker_job_dependency' && (!proposal.targetJobId || !proposal.mode))
+        throw new Error('Blocker-Job dependency resolution requires targetJobId and merge or verified mode');
+    if (proposal.path === 'escalation_gate' && (!proposal.rootCause || !proposal.solution))
+        throw new Error('Escalation gate resolution requires rootCause and solution');
+    if (proposal.path === 'cancel_supersede' && !proposal.rootCause)
+        throw new Error('Cancellation/supersession requires an explicit obsolescence rootCause');
+}
+export function resolutionFacts(task, proposal, owner) {
+    return { recoveryOwnerAvailable: owner === 'troubleshooter', plannerOwnerAvailable: owner !== null && owner !== 'troubleshooter', exactOriginalRetry: proposal.path === 'exact_original_retry', sameJobDependency: proposal.path === 'same_job_dependency', blockerJobDependency: proposal.path === 'blocker_job_dependency', escalationGate: proposal.path === 'escalation_gate', genuinelyObsolete: proposal.path === 'cancel_supersede', unresolved: unresolvedTask(task) };
+}
+export function decideTaskResolution(task, proposal, owner) {
+    return dispatchWorkflowGraphSync(taskResolutionV2, { initialState: 'unresolved', input: { transport: 'event', id: 'resolution.propose', payload: proposal }, durableFacts: resolutionFacts(task, proposal, owner), graphName: 'task-resolution', isTransientState: state => state === 'check_owner' || state === 'check_path', maxSteps: 4 });
+}
+export function dispatchTaskResolutionSync(task, proposal, owner, effects) {
+    const handlers = {
+        'resolution.activateRecovery': effects.activateRecovery,
+        'resolution.attachSameJobDependency': effects.attachSameJobDependency,
+        'resolution.registerBlockerDependency': effects.registerBlockerDependency,
+        'resolution.createEscalationGate': effects.createEscalationGate,
+        'resolution.cancelSupersede': effects.cancelSupersede,
+    };
+    return dispatchWorkflowGraphSync(taskResolutionV2, {
+        initialState: 'unresolved', input: { transport: 'event', id: 'resolution.propose', payload: proposal },
+        durableFacts: resolutionFacts(task, proposal, owner), graphName: 'task-resolution',
+        isTransientState: state => state === 'check_owner' || state === 'check_path', maxSteps: 6,
+        executeAction: actionId => { const handler = handlers[actionId]; if (!handler)
+            throw new Error(`Task resolution effect ${actionId} is unavailable`); handler(); return {}; },
+    });
+}
+export async function dispatchTaskResolution(task, proposal, owner, effects) {
+    const handlers = {
+        'resolution.activateRecovery': effects.activateRecovery,
+        'resolution.attachSameJobDependency': effects.attachSameJobDependency,
+        'resolution.registerBlockerDependency': effects.registerBlockerDependency,
+        'resolution.createEscalationGate': effects.createEscalationGate,
+        'resolution.cancelSupersede': effects.cancelSupersede,
+    };
+    return dispatchWorkflowGraph(taskResolutionV2, {
+        initialState: 'unresolved',
+        input: { transport: 'event', id: 'resolution.propose', payload: proposal },
+        durableFacts: resolutionFacts(task, proposal, owner),
+        graphName: 'task-resolution',
+        isTransientState: state => state === 'check_owner' || state === 'check_path',
+        maxSteps: 6,
+        executeAction: async (actionId) => {
+            const handler = handlers[actionId];
+            if (!handler)
+                throw new Error(`Task resolution effect ${actionId} is unavailable`);
+            await handler();
+            return {};
+        },
+    });
+}
+export function materializeResolution(task, proposal, owner, now = new Date().toISOString()) {
+    return { ...proposal, state: proposal.path === 'escalation_gate' || proposal.path === 'blocker_job_dependency' ? 'waiting' : 'active', owner, updatedAt: now };
+}
+/** Apply the graph-selected ownership to the original durable Task under the
+ * caller's existing atomic store boundary. This does not create replacement
+ * identity; the original remains the semantic owner of the outcome. */
+export function attachResolutionOwnership(job, child, proposal, owner) {
+    const original = proposal.targetTaskId ? job.tasks.find(task => task.id === proposal.targetTaskId) : undefined;
+    if (!original)
+        throw new Error(`Resolution target ${proposal.targetTaskId ?? '(missing)'} not found`);
+    if (proposal.path !== 'same_job_dependency')
+        throw new Error(`Planner child resolution ${proposal.path} cannot materialize replacement work; use the dedicated resolution effect`);
+    const normalized = { ...proposal, targetTaskId: child.id };
+    const decision = dispatchTaskResolutionSync(original, normalized, owner, { attachSameJobDependency: () => {
+            if (!original.dependencies.includes(child.id))
+                original.dependencies = [...original.dependencies, child.id];
+            original.resolution = { ...materializeResolution(original, normalized, owner), state: 'waiting' };
+        } });
+    if (!decision.accepted)
+        throw new Error(`Task resolution graph rejected same-Job dependency for ${original.id}`);
+    return original;
+}
+export function claimExactOriginalRecovery(original, recovery) {
+    original.resolution = materializeResolution(original, { path: 'exact_original_retry', targetTaskId: original.id, rootCause: original.failureReason ?? original.error ?? 'durable failure', solution: `Troubleshooter ${recovery.id} diagnosis and exact-original recovery` }, 'troubleshooter');
+}

package/dist/workspace.js

@@ -233,6 +233,17 @@ export async function prepareLocalJobExecutionWorktree(projectPath, job, workspa
     if (remoteRepository && remoteRepository !== job.repository)
         throw new Error(`Primary checkout ${primary} does not match ${job.repository}`);
     const sourceSha = await git(primary, ['rev-parse', '--verify', sourceRef]);
+    // If the canonical checkout already owns this exact source branch, Git
+    // cannot create a second worktree for it. Reuse the canonical checkout
+    // instead. This is especially important for repair Jobs created from an
+    // existing dirty worktree: the uncommitted evidence must remain available.
+    const primaryBranch = await git(primary, ['symbolic-ref', '-q', 'HEAD']).catch(() => '');
+    if (primaryBranch === sourceRef) {
+        const primaryHead = await git(primary, ['rev-parse', 'HEAD']);
+        if (primaryHead !== sourceSha)
+            throw new Error(`Canonical source branch ${sourceRef} changed while preparing execution checkout`);
+        return projectRelative ? join(primary, projectRelative) : primary;
+    }
     const worktree = managedLocalJobWorktreePath(job.repository, job.id, workspaceRoot);
     await mkdir(dirname(worktree), { recursive: true });
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.76",
+  "version": "2.0.78",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {

package/workflow/planner-orchestration.mmd

@@ -5,6 +5,7 @@ checkLegacy["state: check_legacy_pending"]
 checkRecover["state: check_recover"]
 checkSeed["state: check_seed"]
 checkPlanner["state: check_planner"]
+checkResolution["state: check_resolution_ownership"]
 checkBlocked["state: check_blocked"]
 checkWork["state: check_work"]
 checkMaterialized["state: check_materialized"]
@@ -18,6 +19,7 @@ legacyPending["guard: legacyPlanningPending"]
 recoverablePending["guard: recoverablePendingPlan"]
 hasSeed["guard: hasSeedWork"]
 noActivePlanner["guard: noActivePlanner"]
+resolutionOwned["guard: resolutionOwnedByTroubleshooter"]
 noBlocked["guard: noBlockedWork"]
 noActiveWork["guard: noActiveImplementation"]
 materialized["guard: continuationMaterialized"]
@@ -45,7 +47,11 @@ hasSeed -->|true| checkPlanner
 
 checkPlanner -->|on: planner.reconcile| noActivePlanner
 noActivePlanner -->|false| wait
-noActivePlanner -->|true| checkBlocked
+noActivePlanner -->|true| checkResolution
+
+checkResolution -->|on: planner.reconcile| resolutionOwned
+resolutionOwned -->|true| wait
+resolutionOwned -->|false| checkBlocked
 
 checkBlocked -->|on: planner.reconcile| noBlocked
 noBlocked -->|false| wait

package/workflow/task-resolution.mmd

@@ -0,0 +1,41 @@
+flowchart LR
+%% relay: initial unresolved
+unresolved["state: unresolved"]
+checkOwner["state: check_owner"]
+checkPath["state: check_path"]
+activeRecovery["action: resolution.activateRecovery"]
+sameJob["action: resolution.attachSameJobDependency"]
+blockerJob["action: resolution.registerBlockerDependency"]
+escalate["action: resolution.createEscalationGate"]
+obsolete["action: resolution.cancelSupersede"]
+resolved["state: resolved"]
+recoveryOwner["guard: recoveryOwnerAvailable"]
+plannerOwner["guard: plannerOwnerAvailable"]
+exact["guard: exactOriginalRetry"]
+same["guard: sameJobDependency"]
+blocker["guard: blockerJobDependency"]
+gate["guard: escalationGate"]
+obsoleteGuard["guard: genuinelyObsolete"]
+
+unresolved -->|on: resolution.propose| checkOwner
+checkOwner -->|on: resolution.propose| recoveryOwner
+recoveryOwner -->|true| checkPath
+recoveryOwner -->|false| plannerOwner
+plannerOwner -->|true| checkPath
+plannerOwner -->|false| resolved
+checkPath -->|on: resolution.propose| exact
+exact -->|true| activeRecovery
+exact -->|false| same
+same -->|true| sameJob
+same -->|false| blocker
+blocker -->|true| blockerJob
+blocker -->|false| gate
+gate -->|true| escalate
+gate -->|false| obsoleteGuard
+obsoleteGuard -->|true| obsolete
+obsoleteGuard -->|false| resolved
+activeRecovery -->|to: resolved| resolved
+sameJob -->|to: resolved| resolved
+blockerJob -->|to: resolved| resolved
+escalate -->|to: resolved| resolved
+obsolete -->|to: resolved| resolved