patchrelay 0.78.1 → 0.80.0

package/dist/run-wake-planner.js

@@ -1,10 +1,14 @@
 import { getCiRepairBudget, getQueueRepairBudget, getReviewFixBudget, } from "./run-budgets.js";
 import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
+import { parseRunContextOrWarn, serializeRunContext } from "./run-context.js";
+import { assertNever } from "./utils.js";
 const WRITER = "run-wake-planner";
 export class RunWakePlanner {
     db;
-    constructor(db) {
+    logger;
+    constructor(db, logger) {
         this.db = db;
+        this.logger = logger;
     }
     resolveRunWake(issue) {
         const sessionWake = this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId);
@@ -22,46 +26,52 @@ export class RunWakePlanner {
         let eventType;
         let dedupeKey;
         let eventContext = context;
-        if (runType === "queue_repair") {
-            eventType = "merge_steward_incident";
-            dedupeKey = `${dedupeScope ?? "wake"}:queue_repair:${issue.linearIssueId}:${issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown-sha"}`;
-        }
-        else if (runType === "ci_repair") {
-            eventType = "settled_red_ci";
-            dedupeKey = `${dedupeScope ?? "wake"}:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? "unknown-sha"}`;
-        }
-        else if (runType === "review_fix" || runType === "branch_upkeep") {
-            eventType = "review_changes_requested";
-            const identity = buildRequestedChangesWakeIdentity({
-                linearIssueId: issue.linearIssueId,
-                runType,
-                headSha: issue.prHeadSha,
-            });
-            dedupeKey = identity.dedupeKey;
-            eventContext = {
-                ...context,
-                requestedChangesCoalesceKey: identity.coalesceKey,
-                ...(identity.headSha ? { requestedChangesHeadSha: identity.headSha } : {}),
-            };
-        }
-        else {
-            eventType = "delegated";
-            dedupeKey = `${dedupeScope ?? "wake"}:implementation:${issue.linearIssueId}`;
+        switch (runType) {
+            case "queue_repair":
+                eventType = "merge_steward_incident";
+                dedupeKey = `${dedupeScope ?? "wake"}:queue_repair:${issue.linearIssueId}:${issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown-sha"}`;
+                break;
+            case "ci_repair":
+                eventType = "settled_red_ci";
+                dedupeKey = `${dedupeScope ?? "wake"}:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? "unknown-sha"}`;
+                break;
+            case "review_fix":
+            case "branch_upkeep": {
+                eventType = "review_changes_requested";
+                const identity = buildRequestedChangesWakeIdentity({
+                    linearIssueId: issue.linearIssueId,
+                    runType,
+                    headSha: issue.prHeadSha,
+                });
+                dedupeKey = identity.dedupeKey;
+                eventContext = {
+                    ...context,
+                    requestedChangesCoalesceKey: identity.coalesceKey,
+                    ...(identity.headSha ? { requestedChangesHeadSha: identity.headSha } : {}),
+                };
+                break;
+            }
+            case "implementation":
+                eventType = "delegated";
+                dedupeKey = `${dedupeScope ?? "wake"}:implementation:${issue.linearIssueId}`;
+                break;
+            default:
+                return assertNever(runType, "Unhandled run type in wake event append");
         }
         return Boolean(this.db.issueSessions.appendIssueSessionEventWithLease(lease, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             eventType,
-            ...(eventContext ? { eventJson: JSON.stringify(eventContext) } : {}),
+            ...(eventContext ? { eventJson: serializeRunContext(eventContext, "wake event context") } : {}),
             dedupeKey,
         }));
     }
     materializeLegacyPendingWake(issue, lease) {
         if (!issue.pendingRunType)
             return issue;
-        const context = issue.pendingRunContextJson
-            ? JSON.parse(issue.pendingRunContextJson)
-            : undefined;
+        // Boundary over possibly-old DB rows: a legacy pending context that no
+        // longer parses is dropped (with a warning) instead of wedging the wake.
+        const context = parseRunContextOrWarn(issue.pendingRunContextJson, (message) => this.logger?.warn({ issueKey: issue.issueKey, linearIssueId: issue.linearIssueId }, `Dropping unparseable legacy pending run context: ${message}`), "legacy pending run context");
         this.appendWakeEventWithLease(lease, issue, issue.pendingRunType, context, "legacy_pending");
         const commit = this.db.issueSessions.commitIssueState({
             writer: WRITER,

package/dist/status-note.js

@@ -1,42 +1,60 @@
 import { extractCompletionCheck } from "./completion-check.js";
-import { extractLatestAssistantSummary } from "./issue-session-events.js";
+import { extractLatestAssistantSummary, parseIssueSessionEventOrWarn } from "./issue-session-events.js";
 import { sanitizeOperatorFacingText } from "./presentation-text.js";
+import { assertNever } from "./utils.js";
 function clean(value) {
     return sanitizeOperatorFacingText(value);
 }
+function dirtyWorktreeSummary(payload) {
+    return payload?.dirtyWorktree === true ? payload.summary : undefined;
+}
 function eventStatusNote(event) {
     if (!event)
         return undefined;
-    const payload = event.eventJson ? parseEventJson(event.eventJson) : undefined;
-    const dirtySummary = typeof payload?.summary === "string" && payload.dirtyWorktree === true
-        ? payload.summary
-        : undefined;
-    switch (event.eventType) {
-        case "stop_requested":
+    // Read-model boundary over possibly-old DB rows: degrade a bad payload to
+    // the payload-less note instead of failing the status view.
+    const typed = parseIssueSessionEventOrWarn(event);
+    if (!typed)
+        return undefined;
+    switch (typed.eventType) {
+        case "stop_requested": {
+            const dirtySummary = dirtyWorktreeSummary(typed.payload);
             if (dirtySummary)
                 return `Operator stopped the run with dirty worktree: ${dirtySummary}. Use retry or delegate again to resume.`;
             return "Operator stopped the run. Use retry or delegate again to resume.";
-        case "undelegated":
+        }
+        case "undelegated": {
+            const dirtySummary = dirtyWorktreeSummary(typed.payload);
             if (dirtySummary)
                 return `Issue was un-delegated from PatchRelay with dirty worktree: ${dirtySummary}`;
             return "Issue was un-delegated from PatchRelay. Delegate it again to resume.";
+        }
         case "issue_removed":
             return "Issue was removed from Linear.";
         case "pr_closed":
             return "Pull request was closed without merging.";
         case "pr_merged":
             return "Pull request merged successfully.";
-        default:
+        case "delegated":
+        case "delegation_observed":
+        case "child_changed":
+        case "child_delivered":
+        case "child_regressed":
+        case "direct_reply":
+        case "completion_check_continue":
+        case "followup_prompt":
+        case "followup_comment":
+        case "prompt_delivered":
+        case "self_comment":
+        case "operator_prompt":
+        case "review_changes_requested":
+        case "settled_red_ci":
+        case "merge_steward_incident":
+        case "operator_closed":
+        case "run_released_authority":
             return undefined;
-    }
-}
-function parseEventJson(value) {
-    try {
-        const parsed = JSON.parse(value);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
+        default:
+            return assertNever(typed, "Unhandled issue session event in status note");
     }
 }
 export function deriveIssueStatusNote(params) {

package/dist/tracked-issue-list-query.js

@@ -137,7 +137,11 @@ export class TrackedIssueListQuery {
                 ...(row.last_blocking_review_head_sha !== null ? { lastBlockingReviewHeadSha: String(row.last_blocking_review_head_sha) } : {}),
                 ...(row.last_github_failure_check_name !== null ? { latestFailureCheckName: String(row.last_github_failure_check_name) } : {}),
             });
-            const waitingReason = detachedActiveRun ? derivedWaitingReason : sessionWaitingReason ?? derivedWaitingReason;
+            // The derivation (issue-execution-state.ts via waiting-reason.ts) is the
+            // single source; the stored session projection is only a fallback for
+            // rows whose live facts derive no reason. A detached active run means
+            // the projection is stale, so it is not consulted at all.
+            const waitingReason = derivedWaitingReason ?? (detachedActiveRun ? undefined : sessionWaitingReason);
             const latestRun = row.latest_run_type !== null && row.latest_run_status !== null
                 ? {
                     id: 0,

package/dist/utils.js

@@ -87,6 +87,15 @@ export function safeJsonParse(value) {
         return undefined;
     }
 }
+/**
+ * Exhaustiveness guard for discriminated-union switches (plan §D2): the call
+ * only typechecks when every union member is handled, so adding a new variant
+ * fails compilation at every consumer. At runtime it throws — reaching it
+ * means a value outside the union leaked past a parse boundary.
+ */
+export function assertNever(value, message = "Unexpected value") {
+    throw new Error(`${message}: ${JSON.stringify(value)}`);
+}
 export function redactSensitiveHeaders(headers) {
     return Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, REDACTED_HEADER_NAMES.has(name.toLowerCase()) ? "[redacted]" : value]));
 }

package/dist/waiting-reason.js

@@ -1,4 +1,4 @@
-import { hasOpenPr } from "./pr-state.js";
+import { deriveIssueExecutionState, } from "./issue-execution-state.js";
 export const PATCHRELAY_WAITING_REASONS = {
     activeWork: "PatchRelay is actively working",
     automationPaused: "PatchRelay automation is paused because the issue is undelegated",
@@ -16,82 +16,82 @@ export const PATCHRELAY_WAITING_REASONS = {
     waitingForOperatorIntervention: "Waiting on operator intervention",
     waitingForExternalReview: "Waiting on external review",
 };
+/**
+ * `waitingReason` is a pure function of {@link IssueExecutionState} — the
+ * union (issue-execution-state.ts) is the single derivation of "why is this
+ * issue not moving"; this module only renders it for operators.
+ */
 export function derivePatchRelayWaitingReason(params) {
-    if (params.delegatedToPatchRelay === false && params.factoryState !== "done" && params.factoryState !== "failed" && params.factoryState !== "escalated") {
-        return params.factoryState === "awaiting_queue" || (hasLiveOpenPr(params.prNumber, params.prState) && params.prReviewState === "approved")
-            ? PATCHRELAY_WAITING_REASONS.automationPausedDownstream
-            : PATCHRELAY_WAITING_REASONS.automationPaused;
-    }
-    if (params.activeRunType) {
-        if (hasOpenPr(params.prNumber, params.prState) && (params.factoryState === "pr_open" || params.factoryState === "awaiting_queue")) {
-            return PATCHRELAY_WAITING_REASONS.finalizingPublishedPr;
-        }
-        if (params.factoryState === "done") {
-            return PATCHRELAY_WAITING_REASONS.finalizingMergedChange;
-        }
-        return `PatchRelay is running ${humanize(params.activeRunType)}`;
-    }
-    if (params.activeRunId !== undefined) {
-        return PATCHRELAY_WAITING_REASONS.activeWork;
-    }
-    if (params.orchestrationSettleUntil) {
-        const settleAt = Date.parse(params.orchestrationSettleUntil);
-        if (Number.isFinite(settleAt) && settleAt > Date.now()) {
+    return waitingReasonForExecutionState(deriveIssueExecutionState(params));
+}
+export function waitingReasonForExecutionState(state) {
+    switch (state.kind) {
+        case "undelegated":
+            return state.downstreamMayContinue
+                ? PATCHRELAY_WAITING_REASONS.automationPausedDownstream
+                : PATCHRELAY_WAITING_REASONS.automationPaused;
+        case "running":
+        // An inconsistent row still describes what is observably happening (a run
+        // occupies the slot); reconcilers act on the union kind, not this string.
+        case "inconsistent":
+            return describeRun(state.run);
+        case "settling":
             return PATCHRELAY_WAITING_REASONS.waitingForChildSettle;
-        }
-    }
-    const blockedByKeys = (params.blockedByKeys ?? []).filter((value) => value.trim().length > 0);
-    if (blockedByKeys.length > 0) {
-        return `Blocked by ${blockedByKeys.join(", ")}`;
-    }
-    const checkName = params.latestFailureCheckName ?? "CI";
-    switch (params.factoryState) {
-        case "awaiting_input":
+        case "blocked":
+            return `Blocked by ${state.blockedByKeys.join(", ")}`;
+        case "waiting_input":
             return PATCHRELAY_WAITING_REASONS.waitingForOperatorInput;
-        case "changes_requested":
-            return PATCHRELAY_WAITING_REASONS.waitingForReviewFeedback;
-        case "repairing_ci":
-            return `Waiting to repair ${checkName}`;
-        case "repairing_queue":
-            return PATCHRELAY_WAITING_REASONS.waitingForMergeStewardRepair;
-        case "awaiting_queue":
-            return PATCHRELAY_WAITING_REASONS.waitingForDownstreamAutomation;
-        case "done":
-            return PATCHRELAY_WAITING_REASONS.workComplete;
-        case "failed":
-        case "escalated":
-            return PATCHRELAY_WAITING_REASONS.waitingForOperatorIntervention;
-        default:
+        case "awaiting_followup":
+            switch (state.followup) {
+                case "review_fix":
+                    return PATCHRELAY_WAITING_REASONS.waitingForReviewFeedback;
+                case "ci_repair":
+                    return `Waiting to repair ${state.checkName ?? "CI"}`;
+                case "queue_repair":
+                    return PATCHRELAY_WAITING_REASONS.waitingForMergeStewardRepair;
+            }
             break;
-    }
-    if (params.prCheckStatus === "failed" || params.prCheckStatus === "failure") {
-        return `${checkName} failed`;
-    }
-    if (params.prReviewState === "changes_requested") {
-        if (params.prCheckStatus === "passed" || params.prCheckStatus === "success") {
-            if (params.prHeadSha
-                && params.lastBlockingReviewHeadSha
-                && params.prHeadSha !== params.lastBlockingReviewHeadSha) {
-                return PATCHRELAY_WAITING_REASONS.waitingForReviewOnNewHead;
+        case "terminal":
+            return state.outcome === "done"
+                ? PATCHRELAY_WAITING_REASONS.workComplete
+                : PATCHRELAY_WAITING_REASONS.waitingForOperatorIntervention;
+        case "idle_awaiting_external":
+            switch (state.waitingOn) {
+                case "merge_queue":
+                case "downstream_automation":
+                    return PATCHRELAY_WAITING_REASONS.waitingForDownstreamAutomation;
+                case "ci_failure":
+                    return `${state.checkName ?? "CI"} failed`;
+                case "review_of_new_head":
+                    return PATCHRELAY_WAITING_REASONS.waitingForReviewOnNewHead;
+                case "blocking_review_same_head":
+                    return PATCHRELAY_WAITING_REASONS.sameHeadStillBlocked;
+                case "review_feedback":
+                    return PATCHRELAY_WAITING_REASONS.waitingForReviewFeedback;
+                case "external_review":
+                    return PATCHRELAY_WAITING_REASONS.waitingForExternalReview;
             }
-            return PATCHRELAY_WAITING_REASONS.sameHeadStillBlocked;
-        }
-        return PATCHRELAY_WAITING_REASONS.waitingForReviewFeedback;
-    }
-    if (params.prReviewState === "approved") {
-        return PATCHRELAY_WAITING_REASONS.waitingForDownstreamAutomation;
+            break;
+        case "ready":
+            return `Ready to run ${humanize(state.pendingRunType)}`;
+        case "idle":
+            return undefined;
     }
-    if (hasOpenPr(params.prNumber, params.prState)) {
-        return PATCHRELAY_WAITING_REASONS.waitingForExternalReview;
+    return undefined;
+}
+function describeRun(run) {
+    if (!run.runType) {
+        return PATCHRELAY_WAITING_REASONS.activeWork;
     }
-    if (params.pendingRunType) {
-        return `Ready to run ${humanize(params.pendingRunType)}`;
+    switch (run.phase) {
+        case "finalizing_published_pr":
+            return PATCHRELAY_WAITING_REASONS.finalizingPublishedPr;
+        case "finalizing_merged_change":
+            return PATCHRELAY_WAITING_REASONS.finalizingMergedChange;
+        case "working":
+            return `PatchRelay is running ${humanize(run.runType)}`;
     }
-    return undefined;
 }
 function humanize(value) {
     return value.replaceAll("_", " ");
 }
-function hasLiveOpenPr(prNumber, prState) {
-    return prNumber !== undefined && (prState === undefined || prState === "open");
-}

package/dist/webhooks/issue-update-plan.js

@@ -1,3 +1,4 @@
+import { serializeRunContext } from "../run-context.js";
 /**
  * Picks the single factoryState the caller should write. Priority is the
  * inverse of the previous spread order — the LAST spread wins in JS, so we
@@ -48,7 +49,7 @@ function buildStartupResumeContextJson(input) {
     if (input.startupResume.pendingRunType === undefined)
         return undefined;
     return input.startupResume.pendingRunContext
-        ? JSON.stringify(input.startupResume.pendingRunContext)
+        ? serializeRunContext(input.startupResume.pendingRunContext, "startup resume context")
         : null;
 }
 export function resolveIssueUpdatePlan(input) {

package/dist/workflow-wake-resolver.js

@@ -1,4 +1,5 @@
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
+import { tryParseRunContextValue } from "./run-context.js";
 function parseObjectJson(raw) {
     if (!raw)
         return undefined;
@@ -12,6 +13,17 @@ function parseObjectJson(raw) {
         return undefined;
     }
 }
+// Boundary over reconciliation columns (failure context / queue incident /
+// CI snapshot JSON) merged into an implicit wake's run context. Degrading a
+// schema-rejected value to "no context" matches the pre-existing behavior of
+// parseObjectJson for malformed JSON; the persistence layer has no logger to
+// warn through.
+function parseRunContextColumn(raw) {
+    const value = parseObjectJson(raw);
+    if (!value)
+        return undefined;
+    return tryParseRunContextValue(value);
+}
 function hasUnattemptedFailureSignature(issue, fallbackHeadSha) {
     const signature = issue.lastGitHubFailureSignature;
     if (!signature)
@@ -33,11 +45,11 @@ export function deriveImplicitReactiveWake(issue) {
     if (!reactiveIntent)
         return undefined;
     if (reactiveIntent.runType === "ci_repair") {
-        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson) ?? {};
-        const snapshot = parseObjectJson(issue.lastGitHubCiSnapshotJson);
-        const fallbackHeadSha = typeof failureContext.failureHeadSha === "string"
-            ? failureContext.failureHeadSha
-            : issue.lastGitHubFailureHeadSha ?? issue.prHeadSha;
+        const failureContext = parseRunContextColumn(issue.lastGitHubFailureContextJson) ?? {};
+        const snapshotValue = parseObjectJson(issue.lastGitHubCiSnapshotJson);
+        const snapshot = snapshotValue ? tryParseRunContextValue({ ciSnapshot: snapshotValue })?.ciSnapshot : undefined;
+        const fallbackHeadSha = failureContext.failureHeadSha
+            ?? issue.lastGitHubFailureHeadSha ?? issue.prHeadSha;
         const failureSignature = issue.lastGitHubFailureSignature
             ?? (fallbackHeadSha ? `implicit_branch_ci::${fallbackHeadSha}` : undefined);
         if (!failureSignature || issue.prState !== "open")
@@ -59,11 +71,9 @@ export function deriveImplicitReactiveWake(issue) {
         };
     }
     if (reactiveIntent.runType === "queue_repair") {
-        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson) ?? {};
-        const incidentContext = parseObjectJson(issue.lastQueueIncidentJson) ?? {};
-        const fallbackHeadSha = typeof failureContext.failureHeadSha === "string"
-            ? failureContext.failureHeadSha
-            : undefined;
+        const failureContext = parseRunContextColumn(issue.lastGitHubFailureContextJson) ?? {};
+        const incidentContext = parseRunContextColumn(issue.lastQueueIncidentJson) ?? {};
+        const fallbackHeadSha = failureContext.failureHeadSha;
         if (!hasUnattemptedFailureSignature(issue, fallbackHeadSha))
             return undefined;
         return {

package/package.json

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