agents-relay 2.0.67 → 2.0.69

package/dist/local-merge-projection.js

@@ -0,0 +1,60 @@
+import { execFileSync } from 'node:child_process';
+function git(cwd, ...args) {
+    return execFileSync('git', ['-C', cwd, ...args], {
+        encoding: 'utf8', timeout: 120000, maxBuffer: 1024 * 1024,
+        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+    }).trim();
+}
+function branchRef(name) {
+    if (!/^refs\/heads\/[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(name) || name.includes('..') || name.endsWith('.lock'))
+        throw new Error('Local merge projection requires explicit refs/heads/ target');
+    return name;
+}
+function validSha(value, label) {
+    if (!value || !/^[0-9a-f]{40,64}$/.test(value))
+        throw new Error(`Local merge projection requires valid ${label} SHA`);
+    return value;
+}
+/**
+ * Publish SQLite-authoritative local main using a normal fast-forward push.
+ * GitHub never performs a second merge. Divergence is retried only after
+ * an operator or a separate Git synchronization workflow resolves it.
+ */
+export function projectAuthoritativeLocalMerge(repoPath, job) {
+    const receipt = job.localMerge;
+    if (job.state !== 'COMPLETED' || receipt?.status !== 'succeeded')
+        throw new Error('Authoritative local merge projection requires COMPLETED Job with succeeded merge receipt');
+    const targetRef = branchRef(receipt.targetRef);
+    if (targetRef !== 'refs/heads/main')
+        throw new Error('Local Git target must always be refs/heads/main');
+    const sourceSha = validSha(receipt.sourceSha, 'source');
+    const mergedCommitSha = validSha(receipt.mergedCommitSha, 'merged commit');
+    const localTargetSha = git(repoPath, 'rev-parse', '--verify', targetRef);
+    if (localTargetSha !== mergedCommitSha) {
+        try {
+            git(repoPath, 'merge-base', '--is-ancestor', mergedCommitSha, localTargetSha);
+        }
+        catch {
+            throw new Error(`Local merge target ${targetRef} diverged after authoritative delivery for ${job.id}`);
+        }
+    }
+    const branch = targetRef.slice('refs/heads/'.length);
+    const remoteTracking = `refs/remotes/origin/${branch}`;
+    git(repoPath, 'fetch', '--no-tags', 'origin', `+${targetRef}:${remoteTracking}`);
+    const remoteTargetSha = git(repoPath, 'rev-parse', '--verify', remoteTracking);
+    try {
+        git(repoPath, 'merge-base', '--is-ancestor', localTargetSha, remoteTargetSha);
+        return { targetRef, localMergedCommitSha: mergedCommitSha, remoteTargetSha, projectedCommitSha: remoteTargetSha, status: 'already_projected' };
+    }
+    catch { /* remote projection required */ }
+    // GitHub mirrors the SQLite-authoritative local main; it must never synthesize
+    // a second merge or rewrite the tree when the remote has diverged.
+    try {
+        git(repoPath, 'merge-base', '--is-ancestor', remoteTargetSha, localTargetSha);
+    }
+    catch {
+        throw new Error(`GitHub sync deferred: origin/${branch} diverged from authoritative local main; resolve the remote conflict without force push`);
+    }
+    git(repoPath, 'push', 'origin', `${targetRef}:${targetRef}`);
+    return { targetRef, localMergedCommitSha: mergedCommitSha, remoteTargetSha, projectedCommitSha: localTargetSha, status: 'projected' };
+}

package/dist/managed-worker-input.js

@@ -4,7 +4,10 @@ import { createReviewChairExecutionPlan } from './review-chair.js';
 import { taskTagWorkerPrompt } from './task-tag.js';
 import { executionEventSource } from './reconciler-runtime.js';
 export async function managedWorkerInput(job, task, context) {
-    if (!['codex', 'chatgpt'].includes(task.adapter) || !job.repository || job.prNumber <= 0)
+    const isLocalJob = job.prNumber === 0;
+    const externalPrNumber = job.externalPrNumber && job.externalPrNumber > 0 ? job.externalPrNumber : (job.prNumber > 0 ? job.prNumber : 0);
+    const projectedReview = isLocalJob && task.agentName === 'reviewer' && externalPrNumber > 0;
+    if (!['codex', 'chatgpt'].includes(task.adapter) || !job.repository)
         return task.input;
     const selectedAgent = task.agentName && context ? await agentContractPrompt(context, task.agentName) : '';
     const selectedGraph = task.agentGraph && context ? await agentGraphPrompt(context, task.agentGraph) : '';
@@ -16,19 +19,23 @@ export async function managedWorkerInput(job, task, context) {
     if (!task.executionId)
         throw new Error(`Task ${task.id} requires an executionId before worker input is built`);
     const sourceId = executionEventSource(job.id, task.id, task.executionId);
-    const prUrl = `https://github.com/${job.repository}/pull/${job.prNumber}`;
-    const taskUrl = task.taskUrl ?? `${prUrl}#issuecomment-${task.id}`;
+    const prUrl = externalPrNumber > 0 ? `https://github.com/${job.repository}/pull/${externalPrNumber}` : null;
+    const taskUrl = task.taskUrl ?? (isLocalJob ? `local:${job.id}/task/${task.id}` : `${prUrl}#issuecomment-${task.id}`);
     const output = task.output.kind === 'file'
         ? `file\nPath: ${task.output.path}`
-        : `task/PR\nPR: ${prUrl}\nTask: ${task.id}`;
+        : (projectedReview ? `task/PR\nProjected PR: ${prUrl}\nTask: ${task.id}` : isLocalJob ? `task/PR\nTask: ${task.id}` : `task/PR\nPR: ${prUrl}\nTask: ${task.id}`);
     const taskTag = taskTagWorkerPrompt(job);
     return `[Agents Relay managed task]
-Job URL: ${prUrl}
+${projectedReview ? `Job: local ${job.id} (lifecycle authority)\nProjected GitHub PR: ${prUrl}` : isLocalJob ? `Job: local ${job.id}` : `Job URL: ${prUrl}`}
 Job ID: ${job.id}
 Task URL: ${taskUrl}
 Task ID: ${task.id}
 Project: ${task.projectName ?? context?.project.name ?? 'unspecified'}
-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.
+${projectedReview
+        ? `The local SQLite Job is the lifecycle authority. The projected GitHub PR exists only for artifact/head verification. Review the projected PR at ${prUrl} and verify its exact immutable head against the durable review task input below. Do not use GitHub comments or PR metadata as lifecycle authority.\n\n${task.input}`
+        : 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.`}
 ${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/manual-plan.js

@@ -7,14 +7,36 @@ export async function executeManualPlan(store, jobId, guidance, timeoutMs, launc
     const active = pendingPlan(job);
     if (active && active.executionId)
         throw new Error(`Planning round ${active.id} is already PLANNING`);
-    const round = active ?? createPlanRound(job, { guidance, manual: true, timeoutMs });
-    if (!active)
-        await store.appendPlan(round);
-    job = await store.load(jobId);
-    if (job.state === 'DRAFT') {
-        await applyJobActivateAction(job);
-        await store.saveJob(job);
+    let round = active ?? createPlanRound(job, { guidance, manual: true, timeoutMs });
+    if (store.mutateJob) {
+        const committed = await store.mutateJob(jobId, current => {
+            if (['COMPLETED', 'CANCELLED'].includes(current.state))
+                throw new Error(`Cannot plan terminal job ${current.id} (${current.state})`);
+            const concurrent = pendingPlan(current);
+            if (concurrent) {
+                if (concurrent.executionId)
+                    throw new Error(`Planning round ${concurrent.id} is already PLANNING`);
+                round = structuredClone(concurrent);
+            }
+            else {
+                round = createPlanRound(current, { guidance, manual: true, timeoutMs });
+                current.plans = [...(current.plans ?? []), structuredClone(round)].sort((a, b) => a.round - b.round);
+            }
+            if (current.state === 'DRAFT')
+                applyJobActivateAction(current);
+            return current;
+        });
+        job = structuredClone(committed);
+    }
+    else {
+        if (!active)
+            await store.appendPlan(round);
         job = await store.load(jobId);
+        if (job.state === 'DRAFT') {
+            await applyJobActivateAction(job);
+            await store.saveJob(job);
+            job = await store.load(jobId);
+        }
     }
     const durableRound = (job.plans ?? []).find(plan => plan.id === round.id);
     if (!durableRound)

package/dist/no-github.js

@@ -0,0 +1,11 @@
+import { GhApiClient } from './github-client.js';
+/** No GitHub transport can escape the disabled adapter. */
+export class DisabledGitHubClient extends GhApiClient {
+    async request() { throw new Error('GitHub disabled by --no-github'); }
+    async graphql() { throw new Error('GitHub disabled by --no-github'); }
+    async rateLimitSnapshot() { throw new Error('GitHub disabled by --no-github'); }
+    async currentLogin() { throw new Error('GitHub disabled by --no-github'); }
+}
+export function noGitHubMode(args = process.argv.slice(2)) {
+    return args.includes('--no-github') || process.argv.includes('--no-github') || process.env.AGENTS_RELAY_NO_GITHUB === '1';
+}

package/dist/planned-review-head.js

@@ -1,14 +1,13 @@
 /** A planner-created dependent review must freeze its head only after implementation completes. */
-export async function bindPlannedReviewHead(store, task) {
-    const current = await store.pullRequestHead?.();
-    if (!current?.sha)
-        throw new Error(`Review ${task.id} requires current PR head SHA`);
-    task.reviewHeadSha = current.sha;
+export async function bindPlannedReviewHead(store, task, localHeadSha) {
+    if (!localHeadSha)
+        throw new Error(`Review ${task.id} requires current local Git head SHA`);
+    task.reviewHeadSha = localHeadSha;
     const rule = [
-        'Review the current immutable PR head as a PRE-MERGE approval gate.',
-        'Distinguish code added by this implementation from pre-existing PR baseline/seed files present before the Task started.',
+        'Review the current immutable local source head as a PRE-MERGE approval gate.',
+        'Distinguish code added by this implementation from pre-existing local baseline/seed files present before the Task started.',
         'Preserved baseline files are not automatically extra changes merely because they differ from main; still review them for real risks.',
-        'Do not require PR MERGED, Job COMPLETED, or post-merge E2E evidence before review approval:',
+        'Do not require a remote PR MERGED, Job COMPLETED, or post-merge E2E evidence before review approval:',
         'those events must follow approval and are verified by the independent E2E runner.',
     ].join(' ');
     if (!task.input.includes(rule))

package/dist/planner-runtime.js

@@ -1,10 +1,53 @@
 import { randomUUID } from 'node:crypto';
 import { jobHasActiveExecution } from './job-execution-slot.js';
 import { eventFor } from './events.js';
-import { materializePlannerChild, parsePlannerResult, validatePlannerHierarchy } from './planner.js';
+import { materializePlannerChild, parsePlannerResult, validatePlannerHierarchy, validatePlannerLifecycleOwnership, validatePlannerProgress } from './planner.js';
 import { samePlannerChildDefinition } from './planner-child.js';
 import { withExecutionBoundary } from './reconciler-runtime.js';
 import { storySizeTimeoutMs } from './types.js';
+export async function drainPlannerUnblocks(ports, jobId, planId) {
+    const job = await ports.store.load(jobId);
+    const plan = (job.plans ?? []).find(item => item.id === planId);
+    if (!ports.store.registerBlockerDependent)
+        throw new Error("Blocker registration unavailable");
+    const pending = [...(plan?.pendingUnblocks ?? [])];
+    // Persist only acknowledgments observed by this invocation. Subtract from
+    // the latest transactional snapshot, never replace another drain's intents.
+    const acknowledged = new Set();
+    const key = (item) => JSON.stringify(item);
+    for (const unblock of pending) {
+        try {
+            await ports.store.registerBlockerDependent(jobId, unblock);
+            acknowledged.add(key(unblock));
+        }
+        catch { /* Pending intent is retained for the next reconcile. */ }
+    }
+    if (acknowledged.size > 0) {
+        if (!ports.store.mutateJob)
+            throw new Error('Atomic SQLite mutation is required to acknowledge planner unblocks');
+        await ports.store.mutateJob(jobId, current => {
+            const fresh = (current.plans ?? []).find(item => item.id === planId);
+            if (fresh?.pendingUnblocks?.length) {
+                const outstanding = fresh.pendingUnblocks.filter(item => !acknowledged.has(key(item)));
+                if (outstanding.length)
+                    fresh.pendingUnblocks = outstanding;
+                else
+                    delete fresh.pendingUnblocks;
+                fresh.updatedAt = new Date().toISOString();
+            }
+            return current;
+        });
+    }
+    const refreshed = await ports.store.load(jobId);
+    const remaining = (refreshed.plans ?? []).find(item => item.id === planId)?.pendingUnblocks ?? [];
+    return remaining.map(item => `${item.repository}#${item.prNumber}:${item.jobId}:${item.taskId}`);
+}
+export async function retryPendingPlannerUnblocks(ports, jobId) {
+    const job = await ports.store.load(jobId);
+    for (const plan of (job.plans ?? []).filter(item => item.status === 'SUCCEEDED' && (item.pendingUnblocks?.length ?? 0) > 0)) {
+        await drainPlannerUnblocks(ports, jobId, plan.id);
+    }
+}
 async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
     const live = ports.live.get(planId);
     if (live?.executionId === executionId)
@@ -13,40 +56,65 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
         ports.live.delete(planId); };
     const job = await ports.store.load(jobId);
     const plan = (job.plans ?? []).find(item => item.id === planId);
-    if (!plan || (executionId !== null && plan.executionId !== executionId)) {
+    if (!plan || plan.status !== "PLANNING" || plan.executionId !== executionId) {
         releaseLive();
         return;
     }
     const failOrRetry = async (message) => {
-        const attempt = plan.attempt ?? 0;
-        const maxAttempts = plan.maxAttempts ?? (plan.manualPlanning ? 1 : 3);
-        const retry = attempt < maxAttempts;
-        plan.status = retry ? 'PLANNING' : 'FAILED';
-        plan.retryFeedback = message;
-        plan.error = message;
-        plan.assessment = retry ? `Planning retry: ${message}` : `Planning failed: ${message}`;
-        plan.leaseOwner = null;
-        plan.leaseExpiresAt = null;
-        plan.executionId = null;
-        plan.updatedAt = new Date().toISOString();
-        await ports.store.savePlan(plan);
-        await ports.emit(eventFor(job.id, plan.id, null, retry ? 'planner.retry' : 'planner.failed', retry ? 'queued' : 'failed', `Planner ${plan.id}: ${message}`, 'user'));
+        let retry = false;
+        let applied = false;
+        const update = (fresh) => {
+            if (fresh.status !== 'PLANNING' || fresh.executionId !== executionId)
+                return;
+            const attempt = fresh.attempt ?? 0;
+            const maxAttempts = fresh.maxAttempts ?? (fresh.manualPlanning ? 1 : 3);
+            retry = attempt < maxAttempts;
+            fresh.status = retry ? 'PLANNING' : 'FAILED';
+            fresh.retryFeedback = message;
+            fresh.error = message;
+            fresh.assessment = retry ? `Planning retry: ${message}` : `Planning failed: ${message}`;
+            fresh.leaseOwner = null;
+            fresh.leaseExpiresAt = null;
+            fresh.executionId = null;
+            fresh.updatedAt = new Date().toISOString();
+            applied = true;
+        };
+        if (ports.store.mutateJob) {
+            await ports.store.mutateJob(jobId, current => {
+                const fresh = (current.plans ?? []).find(item => item.id === planId);
+                if (fresh)
+                    update(fresh);
+                return current;
+            });
+        }
+        else {
+            const fresh = (await ports.store.load(jobId)).plans?.find(item => item.id === planId);
+            if (fresh) {
+                update(fresh);
+                if (applied)
+                    await ports.store.savePlan(fresh);
+            }
+        }
+        if (!applied)
+            return;
+        await ports.emit(eventFor(jobId, planId, null, retry ? 'planner.retry' : 'planner.failed', retry ? 'queued' : 'failed', `Planner ${planId}: ${message}`, 'user'));
         if (retry && !plan.manualPlanning)
-            ports.detach(ports.reconcile(jobId), jobId, plan.id, 'planner retry reconciliation');
+            ports.detach(ports.reconcile(jobId), jobId, planId, 'planner retry reconciliation');
     };
     if (error) {
         await failOrRetry(error.message);
         releaseLive();
         return;
     }
+    let planCommitted = false;
     try {
         const result = parsePlannerResult(raw);
         const executionContext = await ports.plannerContext(job, plan);
         validatePlannerHierarchy(job.tasks, result.next_tasks);
+        validatePlannerLifecycleOwnership(job, result.next_tasks);
+        validatePlannerProgress(job, result);
         if (result.unblocks.length > 0 && !ports.store.registerBlockerDependent)
             throw new Error('Durable store does not support Planner cross-Job unblock registration');
-        for (const unblock of result.unblocks)
-            await ports.store.registerBlockerDependent?.(job.id, unblock);
         const children = result.next_tasks.map(spec => materializePlannerChild(job, plan, spec, executionContext));
         for (const child of children) {
             const existing = job.tasks.find(item => item.id === child.id);
@@ -54,29 +122,79 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
                 throw new Error(`Planner child ${child.id} already exists with a different definition`);
         }
         const now = new Date().toISOString();
-        plan.status = 'SUCCEEDED';
-        plan.objectiveStatus = result.objective_status;
-        plan.plannerResult = result;
-        plan.assessment = result.assessment;
-        plan.generatedTaskIds = result.next_tasks.map(item => item.id);
-        plan.error = undefined;
-        plan.retryFeedback = undefined;
-        plan.leaseOwner = null;
-        plan.leaseExpiresAt = null;
-        plan.executionId = null;
-        plan.updatedAt = now;
-        await ports.store.savePlan(plan);
-        if (job.changeCycle && !job.changeCycle.consumedByPlannerTaskId && plan.trigger.source === 'unblock') {
-            job.changeCycle.consumedByPlannerTaskId = plan.id;
-            job.updatedAt = now;
-            await ports.store.saveJob(job);
+        if (ports.store.mutateJob) {
+            let committedPlan = false;
+            const committed = await ports.store.mutateJob(job.id, current => {
+                const durablePlan = (current.plans ?? []).find(item => item.id === plan.id);
+                if (!durablePlan || durablePlan.status !== 'PLANNING' || durablePlan.executionId !== executionId)
+                    return current;
+                durablePlan.status = 'SUCCEEDED';
+                durablePlan.objectiveStatus = result.objective_status;
+                durablePlan.plannerResult = result;
+                durablePlan.assessment = result.assessment;
+                durablePlan.generatedTaskIds = result.next_tasks.map(item => item.id);
+                durablePlan.pendingUnblocks = result.unblocks.length > 0 ? structuredClone(result.unblocks) : undefined;
+                durablePlan.error = undefined;
+                durablePlan.retryFeedback = undefined;
+                durablePlan.leaseOwner = null;
+                durablePlan.leaseExpiresAt = null;
+                durablePlan.executionId = null;
+                durablePlan.updatedAt = now;
+                if (current.changeCycle && !current.changeCycle.consumedByPlannerTaskId && durablePlan.trigger.source === 'unblock') {
+                    current.changeCycle.consumedByPlannerTaskId = durablePlan.id;
+                }
+                for (const child of children) {
+                    const existing = current.tasks.find(item => item.id === child.id);
+                    if (!existing)
+                        current.tasks.push(structuredClone(child));
+                    else if (!samePlannerChildDefinition(existing, child))
+                        throw new Error(`Planner child ${child.id} already exists with a different definition`);
+                }
+                current.updatedAt = now;
+                committedPlan = true;
+                return current;
+            });
+            Object.assign(job, structuredClone(committed));
+            if (!committedPlan) {
+                releaseLive();
+                return;
+            }
+        }
+        else {
+            plan.status = 'SUCCEEDED';
+            plan.objectiveStatus = result.objective_status;
+            plan.plannerResult = result;
+            plan.assessment = result.assessment;
+            plan.generatedTaskIds = result.next_tasks.map(item => item.id);
+            plan.pendingUnblocks = result.unblocks.length > 0 ? structuredClone(result.unblocks) : undefined;
+            plan.error = undefined;
+            plan.retryFeedback = undefined;
+            plan.leaseOwner = null;
+            plan.leaseExpiresAt = null;
+            plan.executionId = null;
+            plan.updatedAt = now;
+            await ports.store.savePlan(plan);
+            if (job.changeCycle && !job.changeCycle.consumedByPlannerTaskId && plan.trigger.source === 'unblock') {
+                job.changeCycle.consumedByPlannerTaskId = plan.id;
+                job.updatedAt = now;
+                await ports.store.saveJob(job);
+            }
+            for (const child of children)
+                if (!job.tasks.some(item => item.id === child.id))
+                    await ports.store.appendTask(child);
         }
-        for (const child of children)
-            if (!job.tasks.some(item => item.id === child.id))
-                await ports.store.appendTask(child);
-        await ports.emit(eventFor(job.id, plan.id, null, 'planner.completed', 'succeeded', `Plan ${plan.id} completed: ${result.objective_status}`, 'orchestrator', { objective_status: result.objective_status }));
+        planCommitted = true;
+        // Cross-Job registrations cannot join this Job's SQLite transaction. The
+        // committed Plan keeps replay intent until each external registration is
+        // confirmed, so a crash or partial failure is recoverable by reconcile.
+        const pendingUnblocks = await drainPlannerUnblocks(ports, job.id, plan.id);
+        await ports.emit(eventFor(job.id, plan.id, null, 'planner.completed', 'succeeded', `Plan ${plan.id} completed: ${result.objective_status}`, 'orchestrator', { objective_status: result.objective_status, pendingUnblocks }));
     }
     catch (caught) {
+        if (planCommitted) {
+            releaseLive();
+            throw caught;
+        }
         await failOrRetry(caught instanceof Error ? caught.message : String(caught));
         releaseLive();
         return;
@@ -88,9 +206,32 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
 export async function launchPlanExecution(ports, job, plan) {
     const planner = ports.options.planner;
     if (!planner) {
-        const failed = { ...plan, status: 'FAILED', error: 'Planner unavailable', assessment: 'Planning failed: Planner unavailable', leaseOwner: null, leaseExpiresAt: null, executionId: null, updatedAt: new Date().toISOString() };
-        await ports.store.savePlan(failed);
-        await ports.emit(eventFor(job.id, plan.id, null, 'planner.failed', 'failed', `Planner ${plan.id}: Planner unavailable`, 'user'));
+        let failed = false;
+        if (ports.store.mutateJob) {
+            await ports.store.mutateJob(job.id, current => {
+                const fresh = current.plans?.find(item => item.id === plan.id);
+                if (fresh?.status === 'PLANNING' && fresh.executionId === plan.executionId) {
+                    fresh.status = 'FAILED';
+                    fresh.error = 'Planner unavailable';
+                    fresh.assessment = 'Planning failed: Planner unavailable';
+                    fresh.leaseOwner = null;
+                    fresh.leaseExpiresAt = null;
+                    fresh.executionId = null;
+                    fresh.updatedAt = new Date().toISOString();
+                    failed = true;
+                }
+                return current;
+            });
+        }
+        else {
+            const fresh = (await ports.store.load(job.id)).plans?.find(item => item.id === plan.id);
+            if (fresh?.status === 'PLANNING' && fresh.executionId === plan.executionId) {
+                await ports.store.savePlan({ ...fresh, status: 'FAILED', error: 'Planner unavailable', assessment: 'Planning failed: Planner unavailable', leaseOwner: null, leaseExpiresAt: null, executionId: null, updatedAt: new Date().toISOString() });
+                failed = true;
+            }
+        }
+        if (failed)
+            await ports.emit(eventFor(job.id, plan.id, null, 'planner.failed', 'failed', `Planner ${plan.id}: Planner unavailable`, 'user'));
         return;
     }
     const claimed = await withExecutionBoundary(job.id, '__job_execution_slot__', async () => {

package/dist/planner.js

@@ -1,4 +1,5 @@
 import { readFile } from 'node:fs/promises';
+import { parseTestInjection } from './e2e-injection.js';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { storySizeTimeoutMs, taskOverallTimeoutMs } from './types.js';
@@ -101,14 +102,14 @@ 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, 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 });
+    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 });
 }
 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, 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 };
 }
 function record(value, field = 'result') {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -286,12 +287,44 @@ export function parsePlannerResult(value) {
             id, parentTaskId, input: task.input, priority, storySize,
             projectName: optionalString(task.projectName, 'projectName'), agentName: optionalString(task.agentName, 'agentName'), agentGraph, review,
             dependencies: stringArray(task.dependencies, 'dependencies'), capabilities: stringArray(task.capabilities, 'capabilities'), workerRequirements: requirements,
+            testInjection: parseTestInjection(task.testInjection ?? task['--test-injection']) ?? optionalString(task.testInjection ?? task['--test-injection'], `next_tasks[${index}].--test-injection`),
             adapter: adapter, output: output, routing: route,
             continuation: task.continuation, maxAttempts, timeoutMs
         };
     });
     return { objective_status: status, assessment: root.assessment, next_tasks, unblocks };
 }
+export function validatePlannerProgress(job, result) {
+    if (result.objective_status !== 'in_progress' || result.next_tasks.length > 0 || result.unblocks.length > 0)
+        return;
+    const previousReviewFinished = job.tasks.some(task => task.agentName === 'reviewer' && task.state === 'SUCCEEDED');
+    if (previousReviewFinished)
+        return;
+    const liveWork = job.tasks.some(task => task.kind !== 'planner' && !['SUCCEEDED', 'FAILED', 'CANCELLED'].includes(task.state));
+    if (liveWork)
+        return;
+    throw new Error('Planner returned in_progress with no executable tasks or unblocks while no live work remains; return satisfied when only Relay-owned review/merge/completion effects remain');
+}
+export function validatePlannerLifecycleOwnership(job, specs) {
+    if (job.prNumber !== 0 || !job.localMerge)
+        return;
+    for (const spec of specs) {
+        // Restrict ownership detection to an individual imperative clause. A long
+        // implementation brief may describe Relay-owned completion as context.
+        const clauses = spec.input.toLowerCase().split(/[.!?\n]+/);
+        for (const clause of clauses) {
+            if (/\b(?:relay|graph|orchestrator)\s+(?:must|will|should|owns?)\b/.test(clause))
+                continue;
+            const localMerge = /\blocal[ -]merge\b|\blocal merge\b/.test(clause);
+            const jobCompletion = /\bjob\b.{0,80}\bcompleted\b|\bcompleted\b.{0,80}\bjob\b/.test(clause);
+            const externalMerge = /\b(?:external|github|projected)\b.{0,80}\bpr\b.{0,80}\bmerged\b|\bpr\b.{0,80}\bmerged\b/.test(clause);
+            const ownsLifecycle = /^\s*(?:perform|execute|complete|trigger|drive|merge|transition|finish|finalize)\b/.test(clause);
+            if (ownsLifecycle && [localMerge, jobCompletion, externalMerge].filter(Boolean).length >= 2) {
+                throw new Error(`Planner next task ${spec.id} attempts to own Graph lifecycle delivery; local merge, Job COMPLETED, and projected PR merge are Relay-owned effects and must not be worker Tasks`);
+            }
+        }
+    }
+}
 export function validatePlannerHierarchy(existing, specs) {
     const existingById = new Map(existing.map(task => [task.id, task]));
     const specsById = new Map(specs.map(spec => [spec.id, spec]));