patchrelay 0.82.0 → 0.83.1

package/dist/webhook-handler.js

@@ -15,6 +15,7 @@ import { WakeDispatcher } from "./wake-dispatcher.js";
 import { CodexFollowupIntentClassifier } from "./followup-intent.js";
 import { AgentInputService } from "./agent-input-service.js";
 import { noopTelemetry } from "./telemetry.js";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.js";
 export class WebhookHandler {
     config;
     db;
@@ -139,6 +140,33 @@ export class WebhookHandler {
                 stopActiveRun: (run, input) => this.stopActiveRun(run, input),
             });
             const trackedIssue = result.issue;
+            this.db.workflowObservations.appendObservation({
+                projectId: project.id,
+                subjectId: issue.id,
+                source: "linear",
+                type: hydrated.triggerEvent === "delegateChanged"
+                    ? result.delegated ? "linear.delegated" : "linear.undelegated"
+                    : `linear.${hydrated.triggerEvent}`,
+                payloadJson: JSON.stringify({
+                    triggerEvent: hydrated.triggerEvent,
+                    webhookId: hydrated.webhookId,
+                    delegated: result.delegated,
+                    issueId: issue.id,
+                    issueKey: issue.identifier,
+                    agentSessionId: hydrated.agentSession?.id,
+                    promptContext: hydrated.agentSession?.promptContext?.trim(),
+                    promptBody: hydrated.agentSession?.promptBody?.trim(),
+                    actorId: hydrated.actor?.id,
+                    actorName: hydrated.actor?.name,
+                }),
+                dedupeKey: hydrated.webhookId,
+            });
+            const observedIssue = this.db.getIssue(project.id, issue.id);
+            let openedRunnableWorkflowTask = false;
+            if (observedIssue) {
+                const workflowReconciliation = reconcileWorkflowTasksForIssue(this.db, observedIssue);
+                openedRunnableWorkflowTask = workflowReconciliation.result.opened.some((task) => task.gateAction === "start" && task.runType);
+            }
             const newlyReadyDependents = this.dependencyReadinessHandler.reconcile(project.id, issue.id);
             const syncTargets = new Set(shouldSyncLinearStateAfterWebhook(hydrated.triggerEvent)
                 ? [issue.id, ...newlyReadyDependents]
@@ -171,36 +199,53 @@ export class WebhookHandler {
             const wakeAlreadyQueuedByFollowUpHandler = normalized.triggerEvent === "commentCreated"
                 || normalized.triggerEvent === "commentUpdated"
                 || normalized.triggerEvent === "agentPrompted";
-            if (result.wakeRunType && !wakeAlreadyQueuedByFollowUpHandler) {
-                const queuedRunType = this.enqueuePendingSessionWake(project.id, issue.id);
-                this.feed?.publish({
-                    level: "info",
-                    kind: "stage",
-                    issueKey: issue.identifier,
-                    projectId: project.id,
-                    stage: queuedRunType ?? result.wakeRunType,
-                    status: "queued",
-                    summary: `Queued ${(queuedRunType ?? result.wakeRunType)} workflow`,
-                    detail: `Triggered by ${hydrated.triggerEvent}.`,
-                });
-            }
-            for (const dependentIssueId of newlyReadyDependents) {
-                // The dependency-readiness handler already dispatched via the
-                // wake dispatcher; here we just emit the operator-feed event so
-                // the dispatched run shows up in the timeline.
-                const dependent = this.db.getTrackedIssue(project.id, dependentIssueId);
-                const queuedRunType = this.peekPendingSessionWakeRunType(project.id, dependentIssueId);
-                this.feed?.publish({
-                    level: "info",
-                    kind: "stage",
-                    issueKey: dependent?.issueKey,
-                    projectId: project.id,
-                    stage: queuedRunType ?? "implementation",
-                    status: "queued",
-                    summary: `Queued ${(queuedRunType ?? "implementation")} after blockers resolved`,
-                    detail: `All blockers are now done for ${dependent?.issueKey ?? dependentIssueId}.`,
-                });
-            }
+            await this.wakeDispatcher.withTick(async () => {
+                if (result.wakeRunType && !wakeAlreadyQueuedByFollowUpHandler) {
+                    const queuedRunType = this.enqueuePendingSessionWake(project.id, issue.id);
+                    this.feed?.publish({
+                        level: "info",
+                        kind: "stage",
+                        issueKey: issue.identifier,
+                        projectId: project.id,
+                        stage: queuedRunType ?? result.wakeRunType,
+                        status: "queued",
+                        summary: `Queued ${(queuedRunType ?? result.wakeRunType)} workflow`,
+                        detail: `Triggered by ${hydrated.triggerEvent}.`,
+                    });
+                }
+                if (openedRunnableWorkflowTask && !wakeAlreadyQueuedByFollowUpHandler) {
+                    const workflowTaskRunType = this.enqueuePendingSessionWake(project.id, issue.id);
+                    if (workflowTaskRunType && !result.wakeRunType) {
+                        this.feed?.publish({
+                            level: "info",
+                            kind: "stage",
+                            issueKey: issue.identifier,
+                            projectId: project.id,
+                            stage: workflowTaskRunType,
+                            status: "queued",
+                            summary: `Queued ${workflowTaskRunType} workflow`,
+                            detail: `Derived after ${hydrated.triggerEvent}.`,
+                        });
+                    }
+                }
+                for (const dependentIssueId of newlyReadyDependents) {
+                    // The dependency-readiness handler already dispatched via the
+                    // wake dispatcher; here we just emit the operator-feed event so
+                    // the dispatched run shows up in the timeline.
+                    const dependent = this.db.getTrackedIssue(project.id, dependentIssueId);
+                    const queuedRunType = this.peekPendingSessionWakeRunType(project.id, dependentIssueId);
+                    this.feed?.publish({
+                        level: "info",
+                        kind: "stage",
+                        issueKey: dependent?.issueKey,
+                        projectId: project.id,
+                        stage: queuedRunType ?? "implementation",
+                        status: "queued",
+                        summary: `Queued ${(queuedRunType ?? "implementation")} after blockers resolved`,
+                        detail: `All blockers are now done for ${dependent?.issueKey ?? dependentIssueId}.`,
+                    });
+                }
+            });
             for (const issueId of syncTargets) {
                 const syncIssue = this.db.getIssue(project.id, issueId);
                 if (!syncIssue) {

package/dist/webhooks/dependency-readiness-handler.js

@@ -1,4 +1,5 @@
 import { emitTelemetry, noopTelemetry } from "../telemetry.js";
+import { reconcileWorkflowTasksForIssue } from "../workflow-task-reconciler.js";
 const WRITER = "dependency-readiness-handler";
 export class DependencyReadinessHandler {
     db;
@@ -57,6 +58,11 @@ export class DependencyReadinessHandler {
             if (!issue.delegatedToPatchRelay || issue.activeRunId !== undefined) {
                 continue;
             }
+            const workflowReconciliation = reconcileWorkflowTasksForIssue(this.db, issue);
+            const hasRunnableWorkflowTask = [
+                ...workflowReconciliation.result.opened,
+                ...workflowReconciliation.result.updated,
+            ].some((task) => task.gateAction === "start" && task.runType);
             const pendingWakeRunType = this.db.workflowWakes.peekIssueWake(projectId, dependent.linearIssueId)?.runType
                 ?? issue.pendingRunType;
             if (pendingWakeRunType) {
@@ -72,6 +78,19 @@ export class DependencyReadinessHandler {
                 newlyReady.push(dependent.linearIssueId);
                 continue;
             }
+            if (hasRunnableWorkflowTask) {
+                const dispatchedRunType = this.wakeDispatcher.dispatchIfWakePending(projectId, dependent.linearIssueId);
+                emitTelemetry(this.telemetry, {
+                    type: "dependency.dependent_unblocked",
+                    projectId,
+                    linearIssueId: dependent.linearIssueId,
+                    ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                    blockerLinearIssueId,
+                    ...(dispatchedRunType ? { dispatchedRunType } : {}),
+                });
+                newlyReady.push(dependent.linearIssueId);
+                continue;
+            }
             if (issue.factoryState !== "delegated" || this.db.issueSessions.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
                 continue;
             }
@@ -86,19 +105,6 @@ export class DependencyReadinessHandler {
                     },
                 });
             }
-            const dispatchedRunType = this.wakeDispatcher.recordEventAndDispatch(projectId, dependent.linearIssueId, {
-                eventType: "delegated",
-                dedupeKey: `delegated:${dependent.linearIssueId}`,
-            });
-            emitTelemetry(this.telemetry, {
-                type: "dependency.dependent_unblocked",
-                projectId,
-                linearIssueId: dependent.linearIssueId,
-                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
-                blockerLinearIssueId,
-                ...(dispatchedRunType ? { dispatchedRunType } : {}),
-            });
-            newlyReady.push(dependent.linearIssueId);
         }
         return newlyReady;
     }

package/dist/webhooks/desired-stage-recorder.js

@@ -141,6 +141,9 @@ export class DesiredStageRecorder {
         const wasResolved = isResolvedLinearState(existingIssue?.currentLinearStateType, existingIssue?.currentLinearState);
         const isResolved = isResolvedLinearState(issue.currentLinearStateType, issue.currentLinearState);
         if (workflowPlan.undelegation.factoryState) {
+            if (activeRun && releaseReason) {
+                this.db.runs.revokeRunLease(activeRun.id, { reason: releaseReason });
+            }
             if (activeRun?.threadId && activeRun.turnId) {
                 await params.stopActiveRun(activeRun, "STOP: The issue was un-delegated from PatchRelay. Stop working immediately and exit.");
             }
@@ -205,24 +208,6 @@ export class DesiredStageRecorder {
                 summary: "Waiting briefly for child issues to settle before orchestration starts",
             });
         }
-        else if (!workflowPlan.startupResume.factoryState
-            && !workflowPlan.startupResume.pendingRunType
-            && workflowPlan.desiredStage === "implementation"
-            && params.normalized.triggerEvent !== "commentCreated"
-            && params.normalized.triggerEvent !== "commentUpdated"
-            && params.normalized.triggerEvent !== "agentPrompted") {
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.project.id, normalizedIssue.id, {
-                projectId: params.project.id,
-                linearIssueId: normalizedIssue.id,
-                eventType: "delegated",
-                eventJson: JSON.stringify({
-                    promptContext: params.normalized.agentSession?.promptContext?.trim()
-                        ?? (issue.issueKey ? `Linear issue ${issue.issueKey} was delegated to PatchRelay.` : undefined),
-                    promptBody: params.normalized.agentSession?.promptBody?.trim(),
-                }),
-                dedupeKey: `delegated:${normalizedIssue.id}`,
-            });
-        }
         if (previousParentIssueId && previousParentIssueId !== currentParentIssueId) {
             wakeOrchestrationParentsForChildEvent({
                 db: this.db,

package/dist/workflow-runtime.js

@@ -0,0 +1,384 @@
+import { buildFailureContext } from "./idle-reconciliation-helpers.js";
+import { tryParseRunContextValue } from "./run-context.js";
+function parseObservationPayload(observation) {
+    if (!observation.payloadJson)
+        return undefined;
+    try {
+        const parsed = JSON.parse(observation.payloadJson);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function deriveAuthority(issue, observations) {
+    let delegated = issue.delegatedToPatchRelay;
+    let epoch = 0;
+    let source = "linear";
+    let observedAt;
+    for (const observation of observations) {
+        if (observation.type !== "linear.delegated" && observation.type !== "linear.undelegated" && observation.type !== "operator.authority_changed") {
+            continue;
+        }
+        epoch += 1;
+        source = observation.source === "operator" ? "operator" : "linear";
+        observedAt = observation.observedAt;
+        const payload = parseObservationPayload(observation);
+        if (typeof payload?.delegated === "boolean") {
+            delegated = payload.delegated;
+            continue;
+        }
+        delegated = observation.type !== "linear.undelegated";
+    }
+    return {
+        delegated,
+        epoch,
+        source,
+        ...(observedAt ? { observedAt } : {}),
+    };
+}
+function issueStatus(issue, blockerCount) {
+    if (issue.factoryState === "done" || issue.prState === "merged")
+        return "done";
+    if (issue.factoryState === "failed" || issue.factoryState === "escalated")
+        return "failed";
+    if (issue.activeRunId !== undefined)
+        return "running";
+    if (!issue.delegatedToPatchRelay || blockerCount > 0 || issue.factoryState === "awaiting_input")
+        return "waiting";
+    return "idle";
+}
+function issueArtifacts(issue) {
+    const artifacts = [];
+    if (issue.branchName) {
+        artifacts.push({ type: "branch", ref: issue.branchName });
+    }
+    if (issue.prNumber !== undefined) {
+        artifacts.push({
+            type: "pr",
+            ref: String(issue.prNumber),
+            ...(issue.prState ? { state: issue.prState } : {}),
+            metadata: {
+                ...(issue.prUrl ? { url: issue.prUrl } : {}),
+                ...(issue.prHeadSha ? { headSha: issue.prHeadSha } : {}),
+                ...(issue.prReviewState ? { reviewState: issue.prReviewState } : {}),
+                ...(issue.prCheckStatus ? { checkStatus: issue.prCheckStatus } : {}),
+            },
+        });
+    }
+    if (issue.threadId) {
+        artifacts.push({ type: "codex_thread", ref: issue.threadId });
+    }
+    if (issue.agentSessionId) {
+        artifacts.push({ type: "linear_session", ref: issue.agentSessionId });
+    }
+    return artifacts;
+}
+function parseCiSnapshotContext(raw) {
+    const payload = parseObjectJson(raw);
+    if (!payload)
+        return undefined;
+    return tryParseRunContextValue({ ciSnapshot: payload })?.ciSnapshot;
+}
+function latestRequestedChangesContext(observations, blockingHeadSha) {
+    for (const observation of [...observations].reverse()) {
+        if (observation.source !== "github" || observation.type !== "github.review_changes_requested") {
+            continue;
+        }
+        const payload = parseObservationPayload(observation);
+        const rawContext = payload?.requestedChangesContext;
+        const context = rawContext && typeof rawContext === "object" && !Array.isArray(rawContext)
+            ? tryParseRunContextValue(rawContext)
+            : tryParseRunContextValue(payload ?? {});
+        if (!context)
+            continue;
+        if (blockingHeadSha
+            && context.requestedChangesHeadSha
+            && context.requestedChangesHeadSha !== blockingHeadSha) {
+            continue;
+        }
+        return context;
+    }
+    return undefined;
+}
+function latestDelegationContext(observations) {
+    for (const observation of [...observations].reverse()) {
+        if (observation.source !== "linear" || observation.type !== "linear.delegated") {
+            continue;
+        }
+        const payload = parseObservationPayload(observation);
+        const context = tryParseRunContextValue({
+            ...(typeof payload?.promptContext === "string" ? { promptContext: payload.promptContext } : {}),
+            ...(typeof payload?.promptBody === "string" ? { promptBody: payload.promptBody } : {}),
+        });
+        if (context && Object.keys(context).length > 0) {
+            return context;
+        }
+    }
+    return undefined;
+}
+function parseObjectJson(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function projectWorkflowSnapshot(input) {
+    const observations = input.observations ?? [];
+    const blockerCount = input.blockerCount ?? 0;
+    const childCount = input.childCount ?? 0;
+    const openChildCount = input.openChildCount ?? childCount;
+    const authority = deriveAuthority(input.issue, observations);
+    const failureContext = buildFailureContext(input.issue);
+    const ciSnapshot = parseCiSnapshotContext(input.issue.lastGitHubCiSnapshotJson);
+    const requestedChangesContext = latestRequestedChangesContext(observations, input.issue.lastBlockingReviewHeadSha);
+    const delegationContext = latestDelegationContext(observations);
+    const baseSnapshot = {
+        id: `${input.issue.projectId}:${input.issue.linearIssueId}`,
+        projectId: input.issue.projectId,
+        subjectId: input.issue.linearIssueId,
+        status: input.activeRun ? "running" : issueStatus({ ...input.issue, delegatedToPatchRelay: authority.delegated }, blockerCount),
+        authority,
+        context: {
+            ...(input.issue.issueKey ? { issueKey: input.issue.issueKey } : {}),
+            ...(input.issue.title ? { title: input.issue.title } : {}),
+            factoryState: input.issue.factoryState,
+            ...(input.issue.lastBlockingReviewHeadSha ? { lastBlockingReviewHeadSha: input.issue.lastBlockingReviewHeadSha } : {}),
+            ...(input.issue.lastGitHubFailureSource ? { lastGitHubFailureSource: input.issue.lastGitHubFailureSource } : {}),
+            ...(input.issue.lastGitHubFailureHeadSha ? { lastGitHubFailureHeadSha: input.issue.lastGitHubFailureHeadSha } : {}),
+            ...(input.issue.lastGitHubFailureSignature ? { lastGitHubFailureSignature: input.issue.lastGitHubFailureSignature } : {}),
+            ...(input.issue.lastAttemptedFailureHeadSha ? { lastAttemptedFailureHeadSha: input.issue.lastAttemptedFailureHeadSha } : {}),
+            ...(input.issue.lastAttemptedFailureSignature ? { lastAttemptedFailureSignature: input.issue.lastAttemptedFailureSignature } : {}),
+            ...(failureContext ? { failureContext } : {}),
+            ...(ciSnapshot ? { ciSnapshot } : {}),
+            ...(requestedChangesContext ? { requestedChangesContext } : {}),
+            ...(delegationContext ? { delegationContext } : {}),
+        },
+        ...(input.activeRun
+            ? { activeRun: input.activeRun }
+            : input.issue.activeRunId !== undefined
+                ? {
+                    activeRun: {
+                        id: input.issue.activeRunId,
+                        runType: input.issue.pendingRunType ?? "implementation",
+                        authorityEpoch: authority.epoch,
+                        status: "running",
+                    },
+                }
+                : {}),
+        artifacts: issueArtifacts(input.issue),
+        blockerCount,
+        childCount,
+        openChildCount,
+    };
+    return {
+        ...baseSnapshot,
+        openTasks: deriveWorkflowTasks(baseSnapshot),
+    };
+}
+export function deriveWorkflowTasks(snapshot) {
+    const tasks = [];
+    if (!snapshot.authority.delegated) {
+        return [{
+                id: "wait:authority",
+                type: "wait",
+                reason: "Workflow is waiting for delegated authority",
+            }];
+    }
+    if (snapshot.status === "done") {
+        return [];
+    }
+    if (snapshot.status === "failed") {
+        return [];
+    }
+    if (snapshot.activeRun) {
+        return [{
+                id: `wait:active-run:${snapshot.activeRun.id}`,
+                type: "wait",
+                reason: "A run is already active",
+            }];
+    }
+    const issue = snapshot.context;
+    const prState = snapshot.artifacts.find((artifact) => artifact.type === "pr")?.state;
+    const prHeadSha = snapshot.artifacts.find((artifact) => artifact.type === "pr")?.metadata?.headSha;
+    const prReviewState = snapshot.artifacts.find((artifact) => artifact.type === "pr")?.metadata?.reviewState;
+    if (issue.factoryState === "awaiting_input") {
+        return [{
+                id: "wait:input",
+                type: "wait",
+                reason: "Workflow is waiting for human input",
+            }];
+    }
+    if (snapshot.blockerCount > 0 && prState !== "open") {
+        return [{
+                id: "wait:blockers",
+                type: "wait",
+                reason: "Workflow is blocked by unresolved Linear dependencies",
+                requirements: { blockerCount: snapshot.blockerCount },
+            }];
+    }
+    if (snapshot.childCount > 0 && prState !== "open") {
+        if (snapshot.openChildCount > 0) {
+            return [{
+                    id: "wait:children",
+                    type: "wait",
+                    reason: "Workflow is waiting for child workflows to complete",
+                    requirements: {
+                        childCount: snapshot.childCount,
+                        openChildCount: snapshot.openChildCount,
+                    },
+                }];
+        }
+        return [{
+                id: "verify:children_complete",
+                type: "verify",
+                reason: "Child workflows are complete; parent objective needs verification",
+                requirements: { childCount: snapshot.childCount },
+            }];
+    }
+    if (prState === "open" && prReviewState === "changes_requested") {
+        tasks.push({
+            id: "run:review_fix",
+            type: "run",
+            runType: "review_fix",
+            reason: "PR has requested changes",
+            requirements: {
+                ...issue.requestedChangesContext,
+                prState,
+                blockingHeadSha: issue.lastBlockingReviewHeadSha ?? prHeadSha,
+                requestedChangesHeadSha: issue.requestedChangesContext?.requestedChangesHeadSha
+                    ?? issue.lastBlockingReviewHeadSha
+                    ?? prHeadSha,
+            },
+        });
+        return tasks;
+    }
+    if (prState === "open" && issue.lastGitHubFailureSource === "queue_eviction") {
+        tasks.push({
+            id: "run:queue_repair",
+            type: "run",
+            runType: "queue_repair",
+            reason: "Merge queue eviction requires repair",
+            requirements: {
+                ...issue.failureContext,
+                failureSignature: issue.lastGitHubFailureSignature,
+                failureHeadSha: issue.lastGitHubFailureHeadSha ?? prHeadSha,
+            },
+        });
+        return tasks;
+    }
+    const branchFailureMatchesCurrentHead = issue.lastGitHubFailureSource === "branch_ci"
+        && typeof issue.lastGitHubFailureSignature === "string"
+        && typeof issue.lastGitHubFailureHeadSha === "string"
+        && typeof prHeadSha === "string"
+        && issue.lastGitHubFailureHeadSha === prHeadSha;
+    const branchFailureAlreadyAttempted = branchFailureMatchesCurrentHead
+        && issue.lastAttemptedFailureHeadSha === issue.lastGitHubFailureHeadSha
+        && issue.lastAttemptedFailureSignature === issue.lastGitHubFailureSignature;
+    if (prState === "open" && branchFailureMatchesCurrentHead && !branchFailureAlreadyAttempted) {
+        tasks.push({
+            id: "run:ci_repair",
+            type: "run",
+            runType: "ci_repair",
+            reason: "Settled branch CI failure requires repair",
+            requirements: {
+                ...issue.failureContext,
+                failureSignature: issue.lastGitHubFailureSignature,
+                failureHeadSha: issue.lastGitHubFailureHeadSha ?? prHeadSha,
+                ...(issue.ciSnapshot ? { ciSnapshot: issue.ciSnapshot } : {}),
+            },
+        });
+        return tasks;
+    }
+    if (!snapshot.artifacts.some((artifact) => artifact.type === "pr") && issue.factoryState === "delegated") {
+        tasks.push({
+            id: "run:implementation",
+            type: "run",
+            runType: "implementation",
+            reason: "Delegated workflow has no PR artifact yet",
+            requirements: {
+                ...issue.delegationContext,
+                blockerCount: snapshot.blockerCount,
+            },
+        });
+    }
+    else if (!snapshot.artifacts.some((artifact) => artifact.type === "pr")) {
+        tasks.push({
+            id: `wait:${issue.factoryState}`,
+            type: "wait",
+            reason: `Workflow is waiting in ${issue.factoryState}`,
+        });
+    }
+    return tasks;
+}
+export function evaluateTaskStart(snapshot, task) {
+    if (!snapshot.authority.delegated) {
+        return { action: "wait", reason: "authority_not_delegated" };
+    }
+    if (snapshot.activeRun) {
+        return { action: "wait", reason: "active_run_present" };
+    }
+    if (task.type !== "run") {
+        return { action: "start" };
+    }
+    if (task.runType === "implementation" && snapshot.blockerCount > 0) {
+        return { action: "wait", reason: "blocked" };
+    }
+    if (task.runType === "review_fix" && typeof task.requirements?.blockingHeadSha !== "string") {
+        return {
+            action: "ask",
+            reason: "missing_blocking_review_head",
+            question: "PatchRelay cannot verify the requested-changes repair without a blocking review head SHA.",
+        };
+    }
+    if ((task.runType === "ci_repair" || task.runType === "queue_repair") && typeof task.requirements?.failureHeadSha !== "string") {
+        return { action: "wait", reason: "missing_failure_head" };
+    }
+    return { action: "start" };
+}
+export function evaluateTaskCompletion(snapshot, task) {
+    if (!snapshot.authority.delegated) {
+        return { action: "wait", reason: "authority_revoked" };
+    }
+    const pr = snapshot.artifacts.find((artifact) => artifact.type === "pr");
+    if (task.runType === "implementation" && (!pr || pr.state !== "open")) {
+        return { action: "escalate", reason: "implementation_completed_without_open_pr" };
+    }
+    if (task.runType === "review_fix") {
+        const blockingHeadSha = task.requirements?.blockingHeadSha;
+        const currentHeadSha = pr?.metadata?.headSha;
+        if (typeof blockingHeadSha !== "string") {
+            return { action: "ask", reason: "missing_blocking_review_head", question: "PatchRelay cannot verify the requested-changes repair without the original head SHA." };
+        }
+        if (currentHeadSha === blockingHeadSha) {
+            return { action: "escalate", reason: "same_head_review_handoff_blocked" };
+        }
+    }
+    if (task.runType === "ci_repair" || task.runType === "queue_repair") {
+        const failureHeadSha = task.requirements?.failureHeadSha;
+        const currentHeadSha = pr?.metadata?.headSha;
+        if (typeof failureHeadSha !== "string") {
+            return {
+                action: "ask",
+                reason: "missing_failure_head",
+                question: "PatchRelay cannot verify the repair without the failing PR head SHA.",
+            };
+        }
+        if (typeof currentHeadSha !== "string") {
+            return { action: "escalate", reason: "repair_completed_without_pr_head" };
+        }
+        if (currentHeadSha === failureHeadSha) {
+            return { action: "escalate", reason: "same_head_repair_handoff_blocked" };
+        }
+    }
+    return { action: "start" };
+}

package/dist/workflow-task-reconciler.js

@@ -0,0 +1,72 @@
+import { evaluateTaskStart, projectWorkflowSnapshot, } from "./workflow-runtime.js";
+function isActiveRun(run) {
+    return run.status === "queued" || run.status === "running";
+}
+function resolveActiveRunSnapshot(db, issue, options) {
+    const pinnedRun = issue.activeRunId !== undefined ? db.runs.getRunById(issue.activeRunId) : undefined;
+    if (pinnedRun && isActiveRun(pinnedRun)) {
+        return {
+            id: pinnedRun.id,
+            runType: pinnedRun.runType,
+            authorityEpoch: pinnedRun.authorityEpoch,
+            status: pinnedRun.status,
+        };
+    }
+    if (options?.ignoreDetachedActiveRuns)
+        return undefined;
+    const run = db.runs.listRunsForIssue(issue.projectId, issue.linearIssueId)
+        .filter(isActiveRun)
+        .at(-1);
+    if (!run)
+        return undefined;
+    return {
+        id: run.id,
+        runType: run.runType,
+        authorityEpoch: run.authorityEpoch,
+        status: run.status,
+    };
+}
+function readinessForTask(snapshot, task) {
+    if (task.type === "wait") {
+        return { action: "wait", reason: task.reason };
+    }
+    if (task.type === "ask") {
+        return {
+            action: "ask",
+            reason: task.reason,
+            question: typeof task.requirements?.question === "string" ? task.requirements.question : task.reason,
+        };
+    }
+    if (task.type === "escalate") {
+        return { action: "escalate", reason: task.reason };
+    }
+    return evaluateTaskStart(snapshot, task);
+}
+export function buildWorkflowSnapshotForIssue(db, issue, options) {
+    const activeRun = resolveActiveRunSnapshot(db, issue, options);
+    return projectWorkflowSnapshot({
+        issue,
+        observations: db.workflowObservations.listObservations(issue.projectId, issue.linearIssueId),
+        blockerCount: db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId),
+        childCount: db.issues.listCanonicalChildIssues(issue.projectId, issue.linearIssueId).length,
+        openChildCount: db.issues.countOpenChildIssues(issue.projectId, issue.linearIssueId),
+        ...(activeRun ? { activeRun } : {}),
+    });
+}
+export function reconcileWorkflowTasksForIssue(db, issue, options) {
+    const snapshot = buildWorkflowSnapshotForIssue(db, issue, options);
+    const result = db.workflowTasks.reconcileTasks({
+        projectId: issue.projectId,
+        subjectId: issue.linearIssueId,
+        tasks: snapshot.openTasks.map((task) => {
+            const decision = readinessForTask(snapshot, task);
+            return {
+                task,
+                authorityEpoch: snapshot.authority.epoch,
+                gateAction: decision.action,
+                ...("reason" in decision ? { gateReason: decision.reason } : {}),
+            };
+        }),
+    });
+    return { snapshot, result };
+}