patchrelay 0.78.1 → 0.79.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/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/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.79.0",
   "license": "MIT",
   "type": "module",
   "repository": {