agents-relay 2.0.67 → 2.0.69

package/dist/reconciler.js

@@ -1,11 +1,15 @@
+import { cancelActiveTasks } from './reconciler-cancellation.js';
+import { authorizedInjection } from './e2e-injection.js';
+import { implementationComplete } from './runtime-status.js';
 import { bindPlannedReviewHead } from './planned-review-head.js';
 import { randomUUID } from 'node:crypto';
 import { storySizeTimeoutMs, chatGptStartAckTimeoutMs } from './types.js';
 import { dependencyReady, schedule, transitionTaskEvent } from './scheduler.js';
-import { applyTaskCancelAction } from './task-actions.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 { 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';
@@ -14,14 +18,15 @@ import { executeManualPlan } from './manual-plan.js';
 import { executionEventSource, withExecutionBoundary } from './reconciler-runtime.js';
 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 { exhaustedTroubleshooterRecoveries, pendingTroubleshooterTasks } from './troubleshooter.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 +45,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 +77,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));
@@ -110,10 +101,49 @@ export class Reconciler extends ReconcilerReviewBase {
                 await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.orchestrator_rescued', 'queued', `Stale orchestrator task ${task.id} converted to ChatGPT execution`, 'orchestrator', { ageMs: rescue.ageMs, adapter: 'chatgpt' }, { agent: 'relay', component: 'agents-relay' }));
             }
             await this.recoverPlannerChildren(job);
+            await retryPendingPlannerUnblocks({
+                store: this.store,
+                options: this.options,
+                live: this.plannerLive,
+                plannerContext: (currentJob, currentPlan) => this.plannerContext(currentJob, currentPlan),
+                emit: event => this.emit(event),
+                detach: (promise, currentJobId, planId, context) => this.detach(promise, currentJobId, planId, context),
+                reconcile: currentJobId => this.reconcile(currentJobId),
+            }, jobId);
             for (const recovery of pendingTroubleshooterTasks(await this.store.load(jobId))) {
                 await this.store.appendTask(recovery);
                 await this.emit(eventFor(job.id, recovery.id, null, "troubleshooter.created", "queued", "Troubleshooter task " + recovery.id + " created for failed/blocked work", "orchestrator", { agentName: "troubleshooter" }));
             }
+            {
+                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;
+                    const original = recoveryJob.tasks.find(task => task.id === recovery.parentTaskId);
+                    if (!original || !['FAILED', 'BLOCKED'].includes(original.state))
+                        continue;
+                    await applyTaskRetryAction(recovery);
+                    recovery.routing = undefined;
+                    recovery.workerSelection = undefined;
+                    await this.store.saveTask(recovery);
+                    await this.emit(eventFor(job.id, recovery.id, original.id, 'troubleshooter.retry_queued', 'queued', `Retrying failed Troubleshooter ${recovery.id} (attempt ${recovery.attempt + 1}/${recovery.maxAttempts})`, 'orchestrator', { originalTaskId: original.id, attempt: recovery.attempt + 1, maxAttempts: recovery.maxAttempts }));
+                }
+                const exhaustedJob = await this.store.load(jobId);
+                for (const exhausted of exhaustedTroubleshooterRecoveries(exhaustedJob)) {
+                    const at = new Date().toISOString();
+                    exhaustedJob.recoveryFailures = [...(exhaustedJob.recoveryFailures ?? []), {
+                            taskId: exhausted.original.id,
+                            recoveryTaskId: exhausted.recovery.id,
+                            reason: exhausted.reason,
+                            at,
+                        }];
+                    exhaustedJob.updatedAt = at;
+                    await this.store.saveJob(exhaustedJob);
+                    await this.emit(eventFor(job.id, exhausted.recovery.id, exhausted.original.id, 'recovery.exhausted', 'failed', `Recovery exhausted for ${exhausted.original.id}: ${exhausted.reason}`, 'user', { originalTaskId: exhausted.original.id, recoveryTaskId: exhausted.recovery.id, reason: exhausted.reason }, { agent: 'relay', component: 'agents-relay' }));
+                }
+            }
             for (const task of job.tasks)
                 if (task.state === 'CANCELLED') {
                     this.cancelExecutionGeneration(job.id, task.id, task.executionId ?? task.executionHistory?.at(-1)?.id);
@@ -129,24 +159,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, this.options.noGitHub === 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 +193,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;
         }
@@ -183,29 +214,11 @@ export class Reconciler extends ReconcilerReviewBase {
         }
     }
     async cancelActiveTasks(jobId, reason) {
-        const job = await this.store.load(jobId);
-        for (const plan of (job.plans ?? []).filter(item => item.status === 'PLANNING')) {
-            const live = this.plannerLive.get(plan.id);
-            if (live) {
-                clearTimeout(live.timer);
-                live.controller.abort();
-                this.plannerLive.delete(plan.id);
-            }
-            plan.status = 'FAILED';
-            plan.error = reason;
-            plan.assessment = `Planning failed: ${reason}`;
-            plan.leaseOwner = null;
-            plan.leaseExpiresAt = null;
-            plan.executionId = null;
-            plan.updatedAt = new Date().toISOString();
-            await this.store.savePlan(plan);
-        }
-        for (const task of job.tasks.filter(item => item.kind !== 'planner' && !['SUCCEEDED', 'FAILED', 'UNBLOCKED', 'CANCELLED'].includes(item.state))) {
-            this.cancelExecutionGeneration(job.id, task.id, task.executionId ?? task.executionHistory?.at(-1)?.id);
-            this.plannerLive.get(task.id)?.controller.abort();
-            await applyTaskCancelAction(task, reason);
-            await this.store.saveTask(task);
-        }
+        return cancelActiveTasks(this.store, jobId, reason, taskId => { const live = this.plannerLive.get(taskId); if (live) {
+            clearTimeout(live.timer);
+            live.controller.abort();
+            this.plannerLive.delete(taskId);
+        } }, (job, taskId, executionId) => { this.cancelExecutionGeneration(job, taskId, executionId); });
     }
     executionRecoveryPorts(job) {
         return {
@@ -223,7 +236,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 +284,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 +319,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 +345,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;
             }
@@ -355,6 +363,31 @@ export class Reconciler extends ReconcilerReviewBase {
                     attempt: freshTask.attempt,
                     startedAt: new Date(startedAt).toISOString(),
                 }].slice(-8);
+            if (this.store.mutateJob) {
+                let claimed;
+                await this.store.mutateJob(job.id, current => {
+                    const durable = current.tasks.find(item => item.id === freshTask.id);
+                    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)
+                        durable.workerSelection = structuredClone(freshTask.workerSelection);
+                    durable.attempt += 1;
+                    durable.leaseOwner = this.options.owner;
+                    durable.leaseExpiresAt = new Date(startedAt + leaseMs).toISOString();
+                    durable.executionId = randomUUID();
+                    durable.executionHistory = [...(durable.executionHistory ?? []), {
+                            id: durable.executionId, attempt: durable.attempt, startedAt: new Date(startedAt).toISOString(),
+                        }].slice(-8);
+                    claimed = structuredClone(durable);
+                    return current;
+                });
+                return claimed;
+            }
             await this.store.saveTask(freshTask);
             return freshTask;
         }) ?? null;
@@ -367,19 +400,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,16 +422,31 @@ 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';
         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 (testInjection) {
+            const durable = (await this.store.load(job.id)).tasks.find(item => item.id === task.id);
+            if (!durable || durable.executionId !== durableExecutionId)
+                return;
+            delete durable.testInjection;
+            durable.updatedAt = new Date(Math.max(Date.now(), Date.parse(durable.updatedAt) + 1)).toISOString();
+            await this.store.saveTask(durable);
+            const consumed = (await this.store.load(job.id)).tasks.find(item => item.id === task.id);
+            if (!consumed || consumed.executionId !== durableExecutionId || consumed.testInjection)
+                throw new Error(`E2E injection consumption was not durably committed for ${task.id}`);
+            delete task.testInjection;
+        }
         const launchContext = {
+            ...(testInjection ? { testInjection } : {}),
             ...(startAckSetup ? { waitForWorkerStart: startAckSetup.ack } : {}),
             ...(terminalWait ? { waitForTerminal: terminalWait.promise } : {}),
             executionContext,

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;