patchrelay 0.81.0 → 0.83.0

package/dist/workflow-runtime.js

@@ -0,0 +1,381 @@
+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.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,64 @@
+import { evaluateTaskStart, projectWorkflowSnapshot, } from "./workflow-runtime.js";
+function isActiveRun(run) {
+    return run.status === "queued" || run.status === "running";
+}
+function resolveActiveRunSnapshot(db, issue) {
+    const pinnedRun = issue.activeRunId !== undefined ? db.runs.getRunById(issue.activeRunId) : undefined;
+    const run = pinnedRun && isActiveRun(pinnedRun)
+        ? pinnedRun
+        : 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) {
+    const activeRun = resolveActiveRunSnapshot(db, issue);
+    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) {
+    const snapshot = buildWorkflowSnapshotForIssue(db, issue);
+    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 };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.81.0",
+  "version": "0.83.0",
   "license": "MIT",
   "type": "module",
   "repository": {