patchrelay 0.78.1 → 0.79.0

package/dist/agent-input-service.js

@@ -1,6 +1,6 @@
 import { buildFollowupStatusActivity, buildNonActionableFollowupActivity, buildPromptDeliveryFailedActivity, buildPromptDeliveredThought, } from "./linear-session-reporting.js";
 import { deriveIssueStatusNote } from "./status-note.js";
-import { extractLatestAssistantSummary } from "./issue-session-events.js";
+import { extractLatestAssistantSummary, } from "./issue-session-events.js";
 import { dirtyWorktreeEventPayload, inspectGitWorktreeStatus } from "./git-worktree-status.js";
 const WRITER = "agent-input-service";
 export class AgentInputService {

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.78.1",
-  "commit": "6907b2e338b5",
-  "builtAt": "2026-06-10T20:42:13.572Z"
+  "version": "0.79.0",
+  "commit": "497f534ca6a5",
+  "builtAt": "2026-06-10T21:17:11.105Z"
 }

package/dist/git-worktree-status.js

@@ -64,6 +64,6 @@ export function dirtyWorktreeEventPayload(status) {
         mergeInProgress: status.mergeInProgress,
         unmergedPaths: status.unmergedPaths,
         changedPaths: status.changedPaths,
-        summary: status.summary,
+        ...(status.summary !== undefined ? { summary: status.summary } : {}),
     };
 }

package/dist/idle-reconciliation-helpers.js

@@ -46,10 +46,8 @@ export function getGateCheckNames(project) {
  * to a stale one without the timestamp check.
  */
 export function isDuplicateRepairAttempt(issue, context) {
-    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
-    const headSha = typeof context?.failureHeadSha === "string"
-        ? context.failureHeadSha
-        : typeof context?.headSha === "string" ? context.headSha : undefined;
+    const signature = context?.failureSignature;
+    const headSha = context?.failureHeadSha ?? context?.headSha;
     if (!signature)
         return false;
     if (issue.lastAttemptedFailureSignature !== signature)

package/dist/idle-reconciliation.js

@@ -6,6 +6,7 @@ import { buildBranchUpkeepContext, buildFailureContext, getGateCheckNames, hasCo
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
+import { serializeRunContext } from "./run-context.js";
 import { buildClosedPrCleanupFields, resolveClosedPrDisposition } from "./pr-state.js";
 import { getReviewFixBudget } from "./run-budgets.js";
 import { queueSettledOrchestrationIssue } from "./orchestration-parent-wake.js";
@@ -348,13 +349,13 @@ export class IdleIssueReconciler {
         this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
             eventType,
             ...(context || requestedChangesIdentity ? {
-                eventJson: JSON.stringify({
+                eventJson: serializeRunContext({
                     ...context,
                     ...(requestedChangesIdentity ? {
                         requestedChangesCoalesceKey: requestedChangesIdentity.coalesceKey,
                         ...(requestedChangesIdentity.headSha ? { requestedChangesHeadSha: requestedChangesIdentity.headSha } : {}),
                     } : {}),
-                }),
+                }, "reconciliation wake context"),
             } : {}),
             dedupeKey,
         });

package/dist/issue-session-events.js

@@ -1,4 +1,171 @@
+import { z } from "zod";
 import { sanitizeOperatorFacingText } from "./presentation-text.js";
+import { runContextSchema } from "./run-context.js";
+import { assertNever } from "./utils.js";
+// ─── Typed session-event payloads (plan §D2) ──────────────────────────
+//
+// Each eventType gets a typed payload; `parseIssueSessionEvent` is the parse
+// boundary over the stringly DB storage (event_json stays JSON text). The
+// same doctrine as D1 applies: malformed payloads fail loudly at parse, and
+// boundary callers that iterate possibly-old DB rows degrade gracefully via
+// `parseIssueSessionEventOrWarn`. All payload schemas are loose objects:
+// legacy rows carry fields newer code no longer writes, and wake payloads are
+// merged wholesale into the run context (which tolerates unknown keys too).
+/** Human input payload for direct_reply / followup_prompt / followup_comment
+ * / operator_prompt. Produced by agent-input-service.ts,
+ * github-pr-comment-handler.ts and webhooks/agent-session-handler.ts;
+ * consumed by deriveSessionWakePlan (followUps + replacement-PR facts). */
+const inputMessagePayloadSchema = z.looseObject({
+    text: z.string().optional(),
+    body: z.string().optional(),
+    author: z.string().optional(),
+    source: z.string().optional(),
+    operatorSource: z.string().optional(),
+    replacementPrRequired: z.boolean().optional(),
+    previousPrNumber: z.number().optional(),
+    previousPrUrl: z.string().optional(),
+    previousPrState: z.string().optional(),
+    previousPrHeadSha: z.string().optional(),
+});
+/** Produced by agent-input-service.ts after steering a running turn;
+ * consumed by run-finalizer.ts summarizePromptDeliveryEvents. */
+const promptDeliveredPayloadSchema = z.looseObject({
+    source: z.string().optional(),
+    runId: z.number().optional(),
+    runType: z.string().optional(),
+    status: z.enum(["delivered", "delivery_failed"]).optional(),
+    body: z.string().optional(),
+    primitive: z.string().optional(),
+    threadId: z.string().optional(),
+    turnId: z.string().optional(),
+    error: z.string().optional(),
+});
+/** Produced by agent-input-service.ts / service-issue-actions.ts /
+ * webhooks/agent-session-handler.ts; consumed by status-note.ts. */
+const stopRequestedPayloadSchema = z.looseObject({
+    body: z.string().optional(),
+    source: z.string().optional(),
+    author: z.string().optional(),
+    // Dirty-worktree facts from git-worktree-status.ts dirtyWorktreeEventPayload.
+    summary: z.string().optional(),
+    dirtyWorktree: z.boolean().optional(),
+    mergeInProgress: z.boolean().optional(),
+    unmergedPaths: z.array(z.string()).optional(),
+    changedPaths: z.array(z.string()).optional(),
+});
+/** Produced by webhooks/desired-stage-recorder.ts; consumed by status-note.ts. */
+const undelegatedPayloadSchema = z.looseObject({
+    // Dirty-worktree facts from git-worktree-status.ts dirtyWorktreeEventPayload.
+    summary: z.string().optional(),
+    dirtyWorktree: z.boolean().optional(),
+    mergeInProgress: z.boolean().optional(),
+    unmergedPaths: z.array(z.string()).optional(),
+    changedPaths: z.array(z.string()).optional(),
+});
+/** Produced by service-issue-actions.ts / cli/data.ts when an operator
+ * force-closes an issue. */
+const operatorClosedPayloadSchema = z.looseObject({
+    terminalState: z.enum(["done", "failed"]).optional(),
+    reason: z.string().optional(),
+});
+/** Audit payloads (delegation-audit.ts) and marker events carry free-form
+ * diagnostic objects; nothing branches on their fields. */
+const freeFormPayloadSchema = z.looseObject({});
+export class IssueSessionEventPayloadError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "IssueSessionEventPayloadError";
+    }
+}
+function parsePayloadJson(event) {
+    if (!event.eventJson)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(event.eventJson);
+    }
+    catch (error) {
+        throw new IssueSessionEventPayloadError(`Malformed ${event.eventType} session-event payload JSON: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new IssueSessionEventPayloadError(`Malformed ${event.eventType} session-event payload: expected a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`);
+    }
+    return parsed;
+}
+function parseWithSchema(event, schema) {
+    const raw = parsePayloadJson(event);
+    if (raw === undefined)
+        return undefined;
+    const result = schema.safeParse(raw);
+    if (!result.success) {
+        throw new IssueSessionEventPayloadError(`Invalid ${event.eventType} session-event payload: ${result.error.issues
+            .map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`)
+            .join("; ")}`, { cause: result.error });
+    }
+    return result.data;
+}
+/**
+ * Parse boundary for session events: returns the typed union member for the
+ * event. FAILS LOUDLY (IssueSessionEventPayloadError) on malformed JSON or
+ * schema violations — boundary callers over possibly-old DB rows should use
+ * `parseIssueSessionEventOrWarn` instead.
+ */
+export function parseIssueSessionEvent(event) {
+    const eventType = event.eventType;
+    switch (eventType) {
+        case "delegated":
+        case "child_changed":
+        case "child_delivered":
+        case "child_regressed":
+        case "completion_check_continue":
+        case "review_changes_requested":
+        case "settled_red_ci":
+        case "merge_steward_incident":
+            return { eventType, payload: parseWithSchema(event, runContextSchema) };
+        case "direct_reply":
+        case "followup_prompt":
+        case "followup_comment":
+        case "operator_prompt":
+            return { eventType, payload: parseWithSchema(event, inputMessagePayloadSchema) };
+        case "prompt_delivered":
+            return { eventType, payload: parseWithSchema(event, promptDeliveredPayloadSchema) };
+        case "stop_requested":
+            return { eventType, payload: parseWithSchema(event, stopRequestedPayloadSchema) };
+        case "operator_closed":
+            return { eventType, payload: parseWithSchema(event, operatorClosedPayloadSchema) };
+        case "undelegated":
+            return { eventType, payload: parseWithSchema(event, undelegatedPayloadSchema) };
+        case "delegation_observed":
+        case "self_comment":
+        case "issue_removed":
+        case "pr_closed":
+        case "pr_merged":
+        case "run_released_authority":
+            return { eventType, payload: parseWithSchema(event, freeFormPayloadSchema) };
+        default:
+            // Also reached at runtime for event_type values written by versions
+            // that no longer exist in the union; the OrWarn boundary degrades them.
+            return assertNever(eventType, "Unknown issue session event type");
+    }
+}
+/**
+ * Boundary variant: parse loudly, but degrade a bad payload to `undefined`
+ * (and an unknown stored event type to `undefined` entirely) after reporting
+ * through `warn`. The parse itself never silently coerces.
+ */
+export function parseIssueSessionEventOrWarn(event, warn) {
+    try {
+        return parseIssueSessionEvent(event);
+    }
+    catch (error) {
+        warn?.(error instanceof Error ? error.message : String(error));
+        if (error instanceof IssueSessionEventPayloadError) {
+            // The event type itself is known — keep the event, drop the payload.
+            return { eventType: event.eventType, payload: undefined };
+        }
+        return undefined;
+    }
+}
 const TERMINAL_SESSION_EVENTS = new Set([
     "stop_requested",
     "operator_closed",
@@ -20,7 +187,7 @@ const RUN_TYPES = new Set(["implementation", "review_fix", "branch_upkeep", "ci_
 function parseRunType(value) {
     return typeof value === "string" && RUN_TYPES.has(value) ? value : undefined;
 }
-export function deriveSessionWakePlan(issue, events) {
+export function deriveSessionWakePlan(issue, events, onPayloadError) {
     const actionableEvents = events.filter((event) => !NON_ACTIONABLE_SESSION_EVENTS.has(event.eventType));
     if (actionableEvents.length === 0)
         return undefined;
@@ -34,53 +201,58 @@ export function deriveSessionWakePlan(issue, events) {
     let runType;
     let resumeThread = false;
     for (const event of actionableEvents) {
-        const payload = parseEventJson(event.eventJson);
-        switch (event.eventType) {
+        // Boundary over DB rows: a payload written by an older version that no
+        // longer matches the schema degrades to "no payload" instead of wedging
+        // wake derivation for the whole issue.
+        const typed = parseIssueSessionEventOrWarn(event, onPayloadError ? (message) => onPayloadError(event, message) : undefined);
+        if (!typed)
+            continue;
+        switch (typed.eventType) {
             case "merge_steward_incident":
                 runType = "queue_repair";
                 wakeReason = "merge_steward_incident";
                 eventIds = [event.id];
-                Object.assign(context, payload ?? {});
+                Object.assign(context, typed.payload ?? {});
                 break;
             case "settled_red_ci":
                 if (runType !== "queue_repair") {
                     runType = "ci_repair";
                     wakeReason = "settled_red_ci";
                     eventIds = [event.id];
-                    Object.assign(context, payload ?? {});
+                    Object.assign(context, typed.payload ?? {});
                 }
                 break;
             case "review_changes_requested":
                 if (runType !== "queue_repair" && runType !== "ci_repair") {
-                    runType = payload?.branchUpkeepRequired === true ? "branch_upkeep" : "review_fix";
-                    wakeReason = payload?.branchUpkeepRequired === true ? "branch_upkeep" : "review_changes_requested";
+                    runType = typed.payload?.branchUpkeepRequired === true ? "branch_upkeep" : "review_fix";
+                    wakeReason = typed.payload?.branchUpkeepRequired === true ? "branch_upkeep" : "review_changes_requested";
                     eventIds = [event.id];
-                    Object.assign(context, payload ?? {});
+                    Object.assign(context, typed.payload ?? {});
                 }
                 break;
             case "delegated":
                 if (!runType) {
-                    runType = parseRunType(payload?.runType) ?? "implementation";
+                    runType = parseRunType(typed.payload?.runType) ?? "implementation";
                     wakeReason = issue.issueClass === "orchestration" ? "initial_delegate" : "delegated";
                     eventIds = [event.id];
                 }
                 else {
                     eventIds.push(event.id);
                 }
-                Object.assign(context, payload ?? {});
+                Object.assign(context, typed.payload ?? {});
                 break;
             case "child_changed":
             case "child_delivered":
             case "child_regressed":
                 if (!runType) {
                     runType = "implementation";
-                    wakeReason = event.eventType;
+                    wakeReason = typed.eventType;
                     eventIds = [event.id];
                 }
                 else {
                     eventIds.push(event.id);
                 }
-                Object.assign(context, payload ?? {});
+                Object.assign(context, typed.payload ?? {});
                 resumeThread = true;
                 break;
             case "direct_reply": {
@@ -92,14 +264,12 @@ export function deriveSessionWakePlan(issue, events) {
                 else {
                     eventIds.push(event.id);
                 }
-                const text = typeof payload?.text === "string"
-                    ? payload.text
-                    : typeof payload?.body === "string" ? payload.body : undefined;
+                const text = typed.payload?.text ?? typed.payload?.body;
                 if (text) {
                     followUps.push({
-                        type: event.eventType,
+                        type: typed.eventType,
                         text,
-                        ...(typeof payload?.author === "string" ? { author: payload.author } : {}),
+                        ...(typed.payload?.author !== undefined ? { author: typed.payload.author } : {}),
                     });
                 }
                 context.directReplyMode = true;
@@ -108,7 +278,7 @@ export function deriveSessionWakePlan(issue, events) {
             }
             case "completion_check_continue": {
                 if (!runType) {
-                    runType = parseRunType(payload?.runType)
+                    runType = parseRunType(typed.payload?.runType)
                         ?? (issue.prReviewState === "changes_requested" ? "review_fix" : "implementation");
                     wakeReason = "completion_check_continue";
                     eventIds = [event.id];
@@ -116,9 +286,9 @@ export function deriveSessionWakePlan(issue, events) {
                 else {
                     eventIds.push(event.id);
                 }
-                Object.assign(context, payload ?? {});
-                if (typeof payload?.summary === "string" && payload.summary.trim()) {
-                    context.completionCheckSummary = payload.summary.trim();
+                Object.assign(context, typed.payload ?? {});
+                if (typed.payload?.summary?.trim()) {
+                    context.completionCheckSummary = typed.payload.summary.trim();
                 }
                 context.completionCheckMode = true;
                 resumeThread = true;
@@ -129,42 +299,49 @@ export function deriveSessionWakePlan(issue, events) {
             case "operator_prompt": {
                 if (!runType) {
                     runType = issue.prReviewState === "changes_requested" ? "review_fix" : "implementation";
-                    wakeReason = issue.issueClass === "orchestration" ? "human_instruction" : event.eventType;
+                    wakeReason = issue.issueClass === "orchestration" ? "human_instruction" : typed.eventType;
                     eventIds = [event.id];
                 }
                 else {
                     eventIds.push(event.id);
                 }
-                const text = typeof payload?.text === "string"
-                    ? payload.text
-                    : typeof payload?.body === "string" ? payload.body : undefined;
+                const text = typed.payload?.text ?? typed.payload?.body;
                 if (text) {
                     followUps.push({
-                        type: event.eventType,
+                        type: typed.eventType,
                         text,
-                        ...(typeof payload?.author === "string" ? { author: payload.author } : {}),
+                        ...(typed.payload?.author !== undefined ? { author: typed.payload.author } : {}),
                     });
                 }
-                if (payload?.replacementPrRequired === true) {
+                if (typed.payload?.replacementPrRequired === true) {
                     context.replacementPrRequired = true;
-                    if (typeof payload.previousPrNumber === "number")
-                        context.previousPrNumber = payload.previousPrNumber;
-                    if (typeof payload.previousPrUrl === "string")
-                        context.previousPrUrl = payload.previousPrUrl;
-                    if (typeof payload.previousPrState === "string")
-                        context.previousPrState = payload.previousPrState;
-                    if (typeof payload.previousPrHeadSha === "string")
-                        context.previousPrHeadSha = payload.previousPrHeadSha;
-                }
-                if (event.eventType === "followup_prompt"
-                    || event.eventType === "followup_comment"
-                    || event.eventType === "operator_prompt") {
-                    resumeThread = true;
+                    if (typed.payload.previousPrNumber !== undefined)
+                        context.previousPrNumber = typed.payload.previousPrNumber;
+                    if (typed.payload.previousPrUrl !== undefined)
+                        context.previousPrUrl = typed.payload.previousPrUrl;
+                    if (typed.payload.previousPrState !== undefined)
+                        context.previousPrState = typed.payload.previousPrState;
+                    if (typed.payload.previousPrHeadSha !== undefined)
+                        context.previousPrHeadSha = typed.payload.previousPrHeadSha;
                 }
+                resumeThread = true;
                 break;
             }
-            default:
+            // Terminal and non-actionable events were filtered out above; listed
+            // here so the switch stays exhaustive over the union.
+            case "delegation_observed":
+            case "prompt_delivered":
+            case "self_comment":
+            case "run_released_authority":
+            case "stop_requested":
+            case "operator_closed":
+            case "undelegated":
+            case "issue_removed":
+            case "pr_closed":
+            case "pr_merged":
                 break;
+            default:
+                assertNever(typed, "Unhandled issue session event in wake derivation");
         }
     }
     if (!runType)
@@ -217,14 +394,3 @@ export function extractLatestAssistantSummary(run) {
     }
     return sanitizeOperatorFacingText(run.failureReason);
 }
-function parseEventJson(raw) {
-    if (!raw)
-        return undefined;
-    try {
-        const parsed = JSON.parse(raw);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/linear-agent-activity-recovery.js

@@ -13,19 +13,13 @@ function hasRecoveredContext(context) {
 function hasLocalHumanContext(context) {
     if (hasRecoveredContext(context))
         return true;
-    for (const key of ["promptContext", "promptBody", "operatorPrompt", "userComment"]) {
-        const value = context?.[key];
+    for (const value of [context?.promptContext, context?.promptBody, context?.operatorPrompt, context?.userComment]) {
         if (typeof value === "string" && value.trim().length > 0)
             return true;
     }
     if (!Array.isArray(context?.followUps))
         return false;
-    return context.followUps.some((entry) => {
-        if (!entry || typeof entry !== "object")
-            return false;
-        const text = entry.text;
-        return typeof text === "string" && text.trim().length > 0;
-    });
+    return context.followUps.some((entry) => typeof entry.text === "string" && entry.text.trim().length > 0);
 }
 function activitySortKey(activity) {
     const parsed = activity.updatedAt ? Date.parse(activity.updatedAt) : NaN;

package/dist/operator-retry-event.js

@@ -1,19 +1,25 @@
 import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
-function parseObjectJson(value) {
+import { tryParseRunContextValue } from "./run-context.js";
+// Boundary over the stored failure/incident columns: malformed JSON or a
+// schema-rejected legacy shape degrades to "no context" (pre-existing
+// behavior of the old parseObjectJson for malformed JSON; this pure module
+// has no logger to warn through).
+function parseRunContextColumn(value) {
     if (!value)
         return undefined;
+    let parsed;
     try {
-        const parsed = JSON.parse(value);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+        parsed = JSON.parse(value);
     }
     catch {
         return undefined;
     }
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? tryParseRunContextValue(parsed) : undefined;
 }
 export function buildOperatorRetryEvent(issue, runType, source = "operator_retry") {
     if (runType === "queue_repair") {
-        const queueIncident = parseObjectJson(issue.lastQueueIncidentJson);
-        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
+        const queueIncident = parseRunContextColumn(issue.lastQueueIncidentJson);
+        const failureContext = parseRunContextColumn(issue.lastGitHubFailureContextJson);
         return {
             eventType: "merge_steward_incident",
             eventJson: JSON.stringify({
@@ -32,7 +38,7 @@ export function buildOperatorRetryEvent(issue, runType, source = "operator_retry
         };
     }
     if (runType === "ci_repair") {
-        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
+        const failureContext = parseRunContextColumn(issue.lastGitHubFailureContextJson);
         return {
             eventType: "settled_red_ci",
             eventJson: JSON.stringify({