agents-relay 2.0.66 → 2.0.68

package/dist/reconciler-review.js

@@ -1,5 +1,5 @@
 import { storySizeTimeoutMs, taskOverallTimeoutMs } from './types.js';
-import { completionGateSatisfied, schedule, transitionTaskEvent, transitionJobEvent, tryTransitionTaskEvent } from './scheduler.js';
+import { completionGateSatisfied, schedule, transitionTaskEvent, tryTransitionTaskEvent } from './scheduler.js';
 import { implementationComplete, implementationTasks } from './runtime-status.js';
 import { eventFor } from './events.js';
 import { workerCandidates } from './worker-routing.js';
@@ -7,16 +7,29 @@ import { routeExecution } from './execution-routing.js';
 import { ReconcilerRuntimeBase } from './reconciler-runtime.js';
 import { dispatchReviewLifecycle, reviewOutcome } from './workflow/review-v2.js';
 import { createTaskEntity } from './workflow/entity-creation.js';
+import { localSourceHead, localWorkingHead } from './local-git-merge.js';
 import { chatgptThreadRequirements, resolveReviewerThreadDestination } from './reviewer-thread.js';
 export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
-    async currentHeadSha(job) { return await this.store.headSha?.() ?? job.headSha ?? job.review?.headSha ?? null; }
-    reviewFacts(job, prState, headSha) {
+    async currentHeadSha(job) {
+        // GitHub PR head facts are audit-only. Source identity is local Git.
+        if (!this.options.projectPathForJob)
+            return job.headSha ?? job.review?.headSha ?? null;
+        try {
+            const project = await this.options.projectPathForJob(job);
+            if (job.localMerge?.sourceRef)
+                return localSourceHead(project, job.localMerge.sourceRef);
+            return localWorkingHead(project);
+        }
+        catch {
+            return job.headSha ?? job.review?.headSha ?? null;
+        }
+    }
+    reviewFacts(job, headSha) {
         const reviewTasks = job.tasks.filter(task => task.agentName === 'reviewer' && task.reviewHeadSha === headSha);
         const currentReviewTask = job.review?.taskId ? job.tasks.find(task => task.id === job.review?.taskId) : undefined;
         return {
             unscheduled: !job.schedule,
             reviewEnabled: job.reviewEnabled !== false,
-            prOpen: prState === 'OPEN',
             jobActive: job.state === 'ACTIVE',
             implementationComplete: implementationComplete(job),
             headAvailable: Boolean(headSha),
@@ -146,9 +159,9 @@ 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 ensureFinalReview(job, prState, headSha) {
+    async ensureFinalReview(job, headSha) {
         let reviewTaskId = null;
-        const decision = await dispatchReviewLifecycle(job.review?.outcome, 'reconcile', this.reviewFacts(job, prState, headSha), async (actionId) => {
+        const decision = await dispatchReviewLifecycle(job.review?.outcome, 'reconcile', this.reviewFacts(job, headSha), async (actionId) => {
             if (actionId !== 'review.create')
                 throw new Error('Unsupported review reconcile action ' + actionId);
             if (!headSha)
@@ -287,7 +300,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const headSha = normalizedEvidence.headSha;
         if (task.reviewHeadSha !== headSha)
             return { applied: false, reconcile: false, reason: event.type + '.stale' };
-        const currentHeadSha = await this.store.headSha?.();
+        const currentHeadSha = await this.currentHeadSha(job);
         if ((currentHeadSha && currentHeadSha !== headSha) || (job.headSha && job.headSha !== headSha))
             return { applied: false, reconcile: false, reason: event.type + '.stale' };
         // Planner-created reviewer tasks predate the final-review Job gate. Bind
@@ -324,10 +337,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
                 return {};
             }
             if (actionId === 'review.requestMerge') {
-                await transitionJobEvent(job, 'review.approved', { autoMerge: true }, async (effectId) => {
-                    const outcomes = await this.workflowEffects.execute([effectId], { jobId: job.id, taskId: task.id, transitionKey: 'review.approved:' + headSha, data: { headSha } });
-                    await this.applyJobEffectOutcomes(job, outcomes);
-                }, async () => { await this.store.saveJob(job); });
+                // Approval is a local fact; only subsequent local Git delivery may complete the Job.
                 return {};
             }
             throw new Error('Unsupported review event action ' + actionId);
@@ -345,6 +355,10 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         job.review = { outcome, headSha, taskId: task.id, evidence, updatedAt: event.timestamp || new Date().toISOString() };
         job.updatedAt = job.review.updatedAt;
         await this.store.saveJob(job);
+        // Review approval records evidence only. The subsequent Graph reconcile
+        // drives durable local Git merge delivery and terminalization.
+        if (outcome === 'approved')
+            needsReconcile = true;
         return { applied: true, reconcile: needsReconcile, reason: 'review.' + outcome, reconcileMode: needsReconcile ? 'detached' : undefined };
     }
 }

package/dist/reconciler-runtime.js

@@ -110,11 +110,21 @@ export class ReconcilerRuntimeBase {
             return activeOwner.applyEvent(event);
         if (event.type === 'task.started')
             return this.markWorkerStarted(event);
-        if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type))
-            return this.applyTerminalEvent(event);
+        if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type)) {
+            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;
+        }
         if (['review.started', 'review.approved', 'review.changes_required', 'review.blocked'].includes(event.type))
             return this.applyReviewEvent(event);
-        if (event.type === 'job.wake' || event.type === 'github.webhook')
+        if (event.type === 'github.webhook')
+            return { applied: true, reconcile: false, reason: 'github.audit_only' };
+        if (event.type === 'job.wake')
             return { applied: true, reconcile: true, reason: event.type };
         return { applied: false, reconcile: false, reason: event.type };
     }
@@ -285,7 +295,7 @@ export class ReconcilerRuntimeBase {
             return;
         if (task.adapter !== 'chatgpt' && task.executionId === executionId && live?.executionId === executionId)
             rearmTerminalEventDeadline(this.terminalTimers, taskId, task.timeoutMs - (Date.now() - live.launchBarrier), this.options.postExitTerminalGraceMs ?? 15_000, () => this.detach(this.timeoutTask(jobId, taskId, executionId), jobId, taskId, 'post-exit terminal event timeout'));
-        await this.emit(eventFor(jobId, taskId, task.parentTaskId, task.adapter === 'chatgpt' ? 'task.process.async_exited' : 'task.process.exited', live?.execution.processExit ? (live.execution.processExit.exitCode === 0 ? 'succeeded' : 'failed') : (error ? 'failed' : 'succeeded'), result?.summary ?? (live?.execution.processExit?.terminationReason === 'parent-shutdown' ? 'Worker interrupted by daemon shutdown' : error ? 'Worker runtime exited with error' : 'Worker runtime exited'), 'orchestrator', { authoritative: false, waitingForTerminalEvent: true, exitCode: live?.execution.processExit?.exitCode ?? null,
+        await this.emit(eventFor(jobId, taskId, task.parentTaskId, task.adapter === 'chatgpt' ? 'task.process.async_exited' : 'task.process.exited', live?.execution.processExit ? (live.execution.processExit.exitCode === 0 ? 'succeeded' : 'failed') : (error ? 'failed' : 'succeeded'), result?.summary ?? (live?.execution.processExit?.terminationReason === 'parent-shutdown' ? 'Worker interrupted by daemon shutdown' : error ? `Worker exited: ${error}${live?.execution.processExit ? ` (exit=${live.execution.processExit.exitCode ?? 'null'}${live.execution.processExit.signal ? ` signal=${live.execution.processExit.signal}` : ''})` : ''}` : 'Worker runtime exited'), 'orchestrator', { authoritative: false, waitingForTerminalEvent: true, exitCode: live?.execution.processExit?.exitCode ?? null,
             signal: live?.execution.processExit?.signal ?? null, terminationReason: live?.execution.processExit?.terminationReason ?? null, stderr: live?.execution.processExit?.stderr ?? '', processError: error, executionId, pid: live?.execution.pid ?? null }, { id: executionEventSource(jobId, taskId, executionId), agent: 'relay', component: 'agents-relay' }));
     }
     async timeoutTask(jobId, taskId, executionId) {
@@ -313,7 +323,7 @@ export class ReconcilerRuntimeBase {
             this.clearExecution(taskId, executionId);
             return;
         }
-        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? failureMessage, 'user', { reason: failureReason, exitCode: exit?.exitCode ?? null, signal: exit?.signal ?? null, timeoutMs: transition.task.timeoutMs, workflowEvent: 'watchdog.failed' }, { agent: 'relay', component: 'agents-relay', watchdog: true });
+        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? failureMessage, 'user', { reason: failureReason, exitCode: exit?.exitCode ?? null, signal: exit?.signal ?? null, timeoutMs: transition.task.timeoutMs, workflowEvent: 'watchdog.failed', executionId }, { agent: 'relay', component: 'agents-relay', watchdog: true });
         await this.emit(event);
         // Provider quota failures are recoverable. Drop the stale selection so the
         // next launch runs the normal worker/model router with fresh usage data.

package/dist/reconciler.js

@@ -1,3 +1,4 @@
+import { implementationComplete } from './runtime-status.js';
 import { bindPlannedReviewHead } from './planned-review-head.js';
 import { randomUUID } from 'node:crypto';
 import { storySizeTimeoutMs, chatGptStartAckTimeoutMs } from './types.js';
@@ -15,13 +16,14 @@ import { executionEventSource, withExecutionBoundary } from './reconciler-runtim
 export { executionEventSource } from './reconciler-runtime.js';
 import { CallbackWorkflowEffectHandler } from './workflow/effects.js';
 import { pendingTroubleshooterTasks } from './troubleshooter.js';
-import { assertCleanWorktreeAtHead, prepareManagedExecutionWorktree, taskUsesCanonicalProjectRun } from './workspace.js';
+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';
 export { managedWorkerInput } from './managed-worker-input.js';
 import { recoverExpiredExecutions, recoverStartupOrphans as recoverStartupExecutionOrphans } from './execution-recovery.js';
 import { dispatchJobReconcile } from './workflow/job-reconcile-v2.js';
+import { reconcileLocalGitCompletion } from './local-merge-delivery.js';
 import { applyOrchestratorRescue } from './workflow/orchestrator-rescue.js';
 import { launchPlanExecution } from './planner-runtime.js';
 import { classifyFailure, errorMessage, observability, withObservabilityCorrelation } from './observability.js';
@@ -40,12 +42,6 @@ export class Reconciler extends ReconcilerReviewBase {
         }, context => `effect.launchTask:${context.jobId}:${context.taskId ?? 'task'}:${String(context.data?.attempt ?? 0)}`));
         this.workflowEffects.register(new CallbackWorkflowEffectHandler('effect.cancelActiveTasks', async (context) => this.cancelActiveTasks(context.jobId, String(context.data?.reason ?? 'Job terminated'))));
         this.workflowEffects.register(new CallbackWorkflowEffectHandler('effect.cleanupJobWorktree', async (context) => cleanupMergedJobWorktree(await this.store.load(context.jobId), this.options.projectPathForJob), context => `effect.cleanupJobWorktree:${context.jobId}`));
-        this.workflowEffects.register(new CallbackWorkflowEffectHandler('effect.mergePullRequest', async (context) => {
-            const headSha = typeof context.data?.headSha === 'string' ? context.data.headSha : null;
-            if (!headSha || !this.store.mergePullRequest)
-                throw new Error('Pull request merge effect requires a head SHA and merge-capable store');
-            await this.store.mergePullRequest(headSha);
-        }, context => `effect.mergePullRequest:${context.jobId}:${String(context.data?.headSha ?? 'missing')}`));
     }
     async dispatchExecutableTasks(jobId) {
         const scheduled = schedule(await this.store.load(jobId));
@@ -78,27 +74,19 @@ 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);
-            const prState = await this.store.pullRequestState?.() ?? 'OPEN';
-            const headSha = prState === 'OPEN' ? await this.currentHeadSha(job) : null;
+            // 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') {
+                    job.localMerge = { ...job.localMerge, sourceSha: undefined, status: 'pending',
+                        error: undefined, nextAttemptAt: undefined, attempts: 0 };
+                }
                 job.headSha = headSha;
                 job.updatedAt = new Date().toISOString();
                 await this.store.saveJob(job);
             }
             await this.invalidateStaleReview(job, headSha);
             const now = (this.options.now ?? new Date()).getTime();
-            if (prState !== 'OPEN') {
-                await dispatchJobReconcile(job, { prState, headSha, mergeCapable: Boolean(this.store.mergePullRequest) }, async (actionId) => {
-                    const outcomes = await this.workflowEffects.execute([actionId], { jobId: job.id, transitionKey: `terminal:${prState}`, data: { reason: `Pull request ${prState.toLowerCase()}` } });
-                    await this.applyJobEffectOutcomes(job, outcomes);
-                }, async () => { await this.store.saveJob(job); });
-                if (prState === 'MERGED' && this.store.resolveBlockerDependents) {
-                    const resolved = await this.store.resolveBlockerDependents(job.id, 'merge');
-                    for (const target of resolved.unblocked)
-                        await this.emit(eventFor(target.jobId, target.taskId, null, 'task.unblocked', 'unblocked', `Blocker Job ${job.id} resolved (merge)`, 'orchestrator', { repository: target.repository, prNumber: target.prNumber, blockerJobId: job.id }));
-                }
-                return this.store.load(jobId);
-            }
             if (job.state !== 'ACTIVE')
                 return job;
             await recoverExpiredExecutions(job, now, this.executionRecoveryPorts(job));
@@ -129,24 +117,25 @@ export class Reconciler extends ReconcilerReviewBase {
             }
             if (scheduled.state !== previousState || JSON.stringify(scheduled.schedule ?? null) !== scheduleBefore)
                 await this.store.saveJob(scheduled);
-            if (prState === 'OPEN') {
-                await this.ensureFinalReview(scheduled, prState, headSha);
+            {
+                await this.ensureFinalReview(scheduled, headSha);
                 scheduled = schedule(await this.store.load(jobId));
             }
-            if (prState === 'OPEN' && scheduled.executionMode === 'autonomous') {
+            if (scheduled.executionMode === 'autonomous') {
                 scheduled = schedule(await this.maybeCreatePlanner(scheduled));
             }
             if (scheduled.state !== previousState || scheduled.updatedAt !== job.updatedAt)
                 await this.store.saveJob(scheduled);
-            if (prState === 'OPEN')
-                scheduled = await this.dispatchExecutableTasks(jobId);
-            const finalState = schedule(await this.store.load(jobId));
+            scheduled = await this.dispatchExecutableTasks(jobId);
+            let finalState = schedule(await this.store.load(jobId));
             if (finalState.updatedAt !== scheduled.updatedAt)
                 await this.store.saveJob(finalState);
-            await this.ensureFinalReview(finalState, prState, headSha);
-            if (prState === 'OPEN')
-                await this.dispatchExecutableTasks(jobId);
-            await dispatchJobReconcile(finalState, { prState, headSha, mergeCapable: Boolean(this.store.mergePullRequest) }, async (actionId) => {
+            await this.ensureFinalReview(finalState, headSha);
+            await this.dispatchExecutableTasks(jobId);
+            finalState = await this.store.load(jobId);
+            if (await reconcileLocalGitCompletion(this.store, finalState, headSha, true, this.options.projectPathForJob))
+                return this.store.load(jobId);
+            await dispatchJobReconcile(finalState, { jobActive: finalState.state === 'ACTIVE', implementationComplete: implementationComplete(finalState), headAvailable: Boolean(headSha), deliveryReady: finalState.localMerge?.status === 'succeeded' }, async (actionId) => {
                 const outcomes = await this.workflowEffects.execute([actionId], { jobId: finalState.id, transitionKey: `reconcile:${headSha ?? 'no-head'}`, data: { headSha } });
                 await this.applyJobEffectOutcomes(finalState, outcomes);
             }, async () => { await this.store.saveJob(finalState); });
@@ -162,7 +151,7 @@ export class Reconciler extends ReconcilerReviewBase {
                     : `Reconcile ${settled.repository}#${settled.prNumber} made no lifecycle change`,
                 correlation: { repository: settled.repository, prNumber: settled.prNumber, jobId: settled.id },
                 transition: { graph: 'job-lifecycle', from: previousState, to: settled.state },
-                data: { prState, tasks: settled.tasks.length },
+                data: { tasks: settled.tasks.length },
             });
             return settled;
         }
@@ -223,7 +212,7 @@ export class Reconciler extends ReconcilerReviewBase {
     async recoverLostExecutions(job, now) { await recoverExpiredExecutions(job, now, this.executionRecoveryPorts(job)); }
     async recoverStartupOrphans(jobId) {
         const job = await this.store.load(jobId);
-        if (job.state === 'ACTIVE' && (await this.store.pullRequestState?.() ?? 'OPEN') === 'OPEN') {
+        if (job.state === 'ACTIVE') {
             await recoverStartupExecutionOrphans(job, this.executionRecoveryPorts(job));
         }
         return this.store.load(jobId);
@@ -271,12 +260,14 @@ export class Reconciler extends ReconcilerReviewBase {
                 job.tasks.push(child);
             }
         }
-        // Legacy read compatibility: migrate historical successful planner Tasks into first-class Plans.
-        const contextTask = job.tasks.find(task => task.kind === 'planner') ?? job.tasks[0];
-        if (!contextTask)
+        // 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;
-        const executionContext = await this.plannerContext(job, contextTask);
-        for (const planner of job.tasks.filter(task => task.kind === 'planner' && task.state === 'SUCCEEDED' && task.plannerResult)) {
+        const executionContext = await this.plannerContext(job, historicalPlanners[0]);
+        for (const planner of historicalPlanners) {
             const result = planner.plannerResult;
             const plan = { jobId: job.id, id: planner.id, round: planner.planningRound ?? 1, source: planner.planningSource ?? 'model-planner', previousPlanId: planner.previousPlannerTaskId ?? null, trigger: planner.planTrigger ?? { source: 'continuation' }, status: 'SUCCEEDED', guidance: planner.plannerGuidance, objectiveStatus: result.objective_status, plannerResult: result, assessment: result.assessment, generatedTaskIds: result.next_tasks.map(item => item.id), headSha: planner.planTrigger?.currentHeadSha ?? job.headSha, attempt: planner.attempt, maxAttempts: planner.maxAttempts, leaseOwner: null, leaseExpiresAt: null, executionId: null, timeoutMs: planner.timeoutMs, manualPlanning: planner.manualPlanning, createdAt: planner.createdAt, updatedAt: planner.updatedAt };
             if (!(job.plans ?? []).some(item => item.id === plan.id)) {
@@ -304,13 +295,6 @@ export class Reconciler extends ReconcilerReviewBase {
     async plannerContext(job, planning) {
         const routingCwd = 'routing' in planning ? planning.routing?.cwd : undefined;
         let projectPath = this.options.projectPathForJob ? await this.options.projectPathForJob(job) : routingCwd ?? process.cwd();
-        if (this.store.pullRequestHead) {
-            const head = await this.store.pullRequestHead();
-            if (!head)
-                throw new Error(`PR #${job.prNumber} has no resolvable head ref`);
-            const key = `planner-${planning.id}-${head.sha.slice(0, 12)}`;
-            projectPath = await prepareManagedExecutionWorktree(projectPath, job.repository, job.prNumber, head, key);
-        }
         return resolveExecutionContext(projectPath, 'planner', {
             ...(this.options.executionContextRoots ?? {}),
             registeredAgents: await this.store.listAgents(),
@@ -337,7 +321,7 @@ export class Reconciler extends ReconcilerReviewBase {
             if (jobHasActiveExecution(freshJob, { taskId: freshTask.id }))
                 return;
             if (freshTask.agentName === 'reviewer' && freshTask.planningDecisionId && freshTask.dependencies.length)
-                await bindPlannedReviewHead(this.store, freshTask);
+                await bindPlannedReviewHead(this.store, freshTask, await this.currentHeadSha(freshJob));
             if (!freshTask.routing && freshTask.adapter !== 'orchestrator') {
                 freshTask = (await this.routeTaskForExecution(freshJob, freshTask)).task;
             }
@@ -367,19 +351,10 @@ export class Reconciler extends ReconcilerReviewBase {
             return;
         }
         let executionContext;
-        let managedHead = null;
         try {
             const role = task.agentName === 'reviewer' ? 'reviewer' : task.agentName === 'troubleshooter' ? 'troubleshooter' : task.parentTaskId ? 'nested-worker' : 'worker';
             let projectPath = this.options.projectPathForJob ? await this.options.projectPathForJob(job) : task.routing?.cwd ?? process.cwd();
             const canonicalProjectRun = taskUsesCanonicalProjectRun(task, job.tasks);
-            if (['codex', 'chatgpt'].includes(task.adapter) && this.store.pullRequestHead && task.executionId && !canonicalProjectRun) {
-                managedHead = await this.store.pullRequestHead();
-                if (!managedHead)
-                    throw new Error(`PR #${job.prNumber} has no resolvable head ref`);
-                projectPath = await prepareManagedExecutionWorktree(projectPath, job.repository, job.prNumber, managedHead, task.executionId);
-                if (role === 'reviewer')
-                    await assertCleanWorktreeAtHead(projectPath, managedHead.sha);
-            }
             executionContext = await this.resolvedContext(job, task, role, projectPath);
         }
         catch (error) {
@@ -398,11 +373,9 @@ export class Reconciler extends ReconcilerReviewBase {
         const sourceId = executionEventSource(job.id, task.id, durableExecutionId);
         const baseWorkerInput = await managedWorkerInput(job, task, executionContext);
         const canonicalProjectRun = taskUsesCanonicalProjectRun(task, job.tasks);
-        const workerInput = managedHead
-            ? `${baseWorkerInput}\n\n[Managed PR checkout]\nExecution cwd: ${executionContext.project.path}\nExpected PR head: ${managedHead.ref} @ ${managedHead.sha}\nThis checkout is isolated from the user's primary checkout. Commit only here. Push durable changes with: git push origin HEAD:${managedHead.ref}\nDo not switch, reset, merge into, or commit on the primary checkout.`
-            : canonicalProjectRun
-                ? `${baseWorkerInput}\n\n[Canonical Neo project run]\nExecution cwd: ${executionContext.project.path}\nThis Task owns or descends from a durable runs/ artifact. Work directly in this canonical project directory so all continuations, reviews, QA, and publication steps share the same runs/ evidence. Do not create or switch to an Agents Relay task worktree for this runtime work. Keep generated/private execution artifacts under runs/ and do not commit them.`
-                : baseWorkerInput;
+        const workerInput = canonicalProjectRun
+            ? `${baseWorkerInput}\n\n[Canonical Neo project run]\nExecution cwd: ${executionContext.project.path}\nKeep generated artifacts under runs/.`
+            : baseWorkerInput;
         const workerTask = { ...task, input: workerInput, routing: task.routing ? { ...task.routing, cwd: executionContext.project.path } : task.routing };
         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';

package/dist/relay-store.js

@@ -2,8 +2,9 @@ import { DatabaseSync } from 'node:sqlite';
 import { dirname } from 'node:path';
 import { mkdirSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
+import { recordPublicationInDatabase, loadPublicationFromDatabase, listPublicationEventsFromDatabase } from './publication-store.js';
 import { observability } from './observability.js';
-import { ProjectionOutbox, SCHEMA_VERSION, } from './projection-outbox.js';
+import { ProjectionOutbox, SCHEMA_VERSION, logicalOperationKey, } from './projection-outbox.js';
 function newerRecord(local, remote) {
     if (!local)
         return structuredClone(remote);
@@ -31,6 +32,12 @@ export function mergeInboundJobSnapshot(local, remote) {
     }
     return base;
 }
+function monotonicJobTimestamp(previous, candidate = new Date().toISOString()) {
+    const prior = Date.parse(previous), next = Date.parse(candidate);
+    if (!Number.isFinite(prior))
+        return candidate;
+    return new Date(Math.max(Number.isFinite(next) ? next : Date.now(), prior + 1)).toISOString();
+}
 export class SQLiteRelayStore {
     path;
     db;
@@ -63,6 +70,8 @@ export class SQLiteRelayStore {
         head_sha TEXT,
         observed_at TEXT NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS publication_state (job_id TEXT PRIMARY KEY, json TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS publication_delivery (job_id TEXT NOT NULL, delivery_id TEXT NOT NULL, type TEXT NOT NULL, json TEXT NOT NULL, observed_at TEXT NOT NULL, PRIMARY KEY(job_id,delivery_id));
       CREATE TABLE IF NOT EXISTS agent_snapshot (
         agent_id TEXT PRIMARY KEY,
         json TEXT NOT NULL,
@@ -99,6 +108,15 @@ export class SQLiteRelayStore {
         this.db.prepare("INSERT INTO relay_meta(key,value) VALUES('schema_version',?) ON CONFLICT(key) DO UPDATE SET value=excluded.value")
             .run(String(SCHEMA_VERSION));
     }
+    async recordPublication(jobId, deliveryId, publication, failure, observedAt) {
+        return recordPublicationInDatabase(this.db, jobId, deliveryId, publication, failure, observedAt);
+    }
+    async loadPublication(jobId) {
+        return loadPublicationFromDatabase(this.db, jobId);
+    }
+    async listPublicationEvents(jobId) {
+        return listPublicationEventsFromDatabase(this.db, jobId);
+    }
     async loadJob(jobId) {
         const row = this.db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(jobId);
         return row?.json ? JSON.parse(row.json) : null;
@@ -110,6 +128,30 @@ export class SQLiteRelayStore {
     async saveJob(job) {
         this.writeJobSnapshot(job, new Date().toISOString());
     }
+    /** Atomic read/modify/write for local authoritative Task and Plan updates. */
+    async mutateJob(jobId, mutation) {
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const row = this.db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(jobId);
+            if (!row?.json)
+                throw new Error(`Local authoritative Job ${jobId} not found`);
+            const current = JSON.parse(row.json);
+            const before = JSON.stringify(current);
+            const next = mutation(current);
+            if (next.id !== jobId)
+                throw new Error('Cannot change authoritative Job identity');
+            if (JSON.stringify(next) !== before && next.updatedAt <= JSON.parse(before).updatedAt) {
+                next.updatedAt = monotonicJobTimestamp(JSON.parse(before).updatedAt);
+            }
+            this.writeJobSnapshot(next, new Date().toISOString());
+            this.db.exec('COMMIT');
+            return structuredClone(next);
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
     async ingestJobSnapshot(job) {
         const now = new Date().toISOString();
         this.db.exec('BEGIN IMMEDIATE');
@@ -176,6 +218,19 @@ export class SQLiteRelayStore {
             throw error;
         }
     }
+    async upsertAgent(agent) {
+        const now = new Date().toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.writeAgentSnapshot(agent, now);
+            this.markAgentRegistryObserved(now);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
     async saveAgentWithProjection(agent, request) {
         const now = new Date().toISOString();
         this.db.exec('BEGIN IMMEDIATE');
@@ -209,9 +264,16 @@ export class SQLiteRelayStore {
         return { state: row.state, head: row.head_ref && row.head_sha ? { ref: row.head_ref, sha: row.head_sha } : null, observedAt: row.observed_at };
     }
     async savePullRequestFacts(facts) {
+        // UNKNOWN means absence of confirmed external evidence; never persist it as a fact.
+        if (facts.state === 'UNKNOWN')
+            return;
         this.db.prepare(`
       INSERT INTO pull_request_facts(id,state,head_ref,head_sha,observed_at) VALUES(1,?,?,?,?)
       ON CONFLICT(id) DO UPDATE SET state=excluded.state,head_ref=excluded.head_ref,head_sha=excluded.head_sha,observed_at=excluded.observed_at
+      WHERE excluded.observed_at >= pull_request_facts.observed_at
+        AND (pull_request_facts.state='OPEN'
+          OR (pull_request_facts.state='CLOSED' AND excluded.state IN ('CLOSED','MERGED'))
+          OR (pull_request_facts.state='MERGED' AND excluded.state='MERGED'))
     `).run(facts.state, facts.head?.ref ?? null, facts.head?.sha ?? null, facts.observedAt);
     }
     async recordExecutionProcess(record) {
@@ -262,6 +324,31 @@ export class SQLiteRelayStore {
             throw error;
         }
     }
+    /**
+     * Idempotent external-effect reservation. Repeated Graph reconciliation
+     * must never reset backoff or queue a second merge while a first one runs.
+     */
+    async enqueueExternalActionOnce(request) {
+        if (!['merge_pull_request', 'close_pull_request', 'update_pr_body'].includes(request.operation)) {
+            throw new Error('Lifecycle projection is forbidden in external-only outbox');
+        }
+        const key = logicalOperationKey(request.idempotencyKey);
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const existing = this.db.prepare('SELECT id FROM projection_outbox WHERE operation_key=? LIMIT 1').get(key);
+            if (existing) {
+                this.db.exec('COMMIT');
+                return false;
+            }
+            this.outbox.enqueue(request, new Date().toISOString());
+            this.db.exec('COMMIT');
+            return true;
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
     async claimDueProjections(limit = 50, now = new Date()) {
         return this.outbox.claimDue(limit, now);
     }
@@ -280,6 +367,12 @@ export class SQLiteRelayStore {
 export function relayStorePath(directory, repository, prNumber) {
     return directory + '/' + `${repository.replace('/', '_')}-${prNumber}.db`;
 }
+export { relayJobStorePath } from './local-job-path.js';
+/**
+ * SQLite is the only job registry. Inventory queries must be strictly read-only:
+ * opening a writable RelayStore here would reset in-flight projection claims
+ * on every dashboard refresh and could replay external merge side effects.
+ */
 export async function discoverLocalRelayStoreSnapshots(directory) {
     let names;
     try {
@@ -291,16 +384,25 @@ export async function discoverLocalRelayStoreSnapshots(directory) {
     const snapshots = [];
     for (const name of names.filter(item => item.endsWith('.db')).sort()) {
         const path = directory + '/' + name;
-        let store;
+        let db;
         try {
-            store = new SQLiteRelayStore(path);
-            snapshots.push({ path, jobs: await store.listJobs(), facts: await store.loadPullRequestFacts() });
+            db = new DatabaseSync(path, { readOnly: true });
+            const rows = db.prepare('SELECT json FROM job_snapshot ORDER BY job_id').all();
+            const jobs = rows.map(row => JSON.parse(row.json));
+            const row = db.prepare('SELECT state,head_ref,head_sha,observed_at FROM pull_request_facts WHERE id=1').get();
+            const facts = row ? {
+                state: row.state,
+                head: row.head_ref && row.head_sha ? { ref: row.head_ref, sha: row.head_sha } : null,
+                observedAt: row.observed_at,
+            } : null;
+            const publications = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='publication_state'").get() ? Object.fromEntries(db.prepare('SELECT job_id,json FROM publication_state').all().map(item => [item.job_id, JSON.parse(item.json)])) : {};
+            snapshots.push({ path, jobs, facts, publications });
         }
         catch {
-            // Ignore unrelated/corrupt files so one bad file cannot block daemon startup.
+            // Ignore unrelated/corrupt files without allowing one damaged store to block recovery.
         }
         finally {
-            store?.close();
+            db?.close();
         }
     }
     return snapshots;