patchrelay 0.78.1 → 0.80.0

package/dist/issue-session-lease-service.js

@@ -1,34 +1,51 @@
 import { randomUUID } from "node:crypto";
-import { getThreadTurns } from "./codex-thread-utils.js";
 import { emitTelemetry, noopTelemetry } from "./telemetry.js";
-const ISSUE_SESSION_LEASE_MS = 10 * 60_000;
+export const ISSUE_SESSION_LEASE_MS = 10 * 60_000;
+/**
+ * Expected heartbeat cadence for a live lease holder. Heartbeats are
+ * notification-driven (every Codex notification renews the lease) rather
+ * than timer-driven, so this is the staleness budget granted to a live
+ * holder, not a timer the service runs. A foreign holder whose inferred
+ * last heartbeat (`leasedUntil - ISSUE_SESSION_LEASE_MS`) is older than
+ * 2x this budget is presumed dead (crashed process) and its lease may be
+ * reclaimed for recovery without waiting for full TTL expiry.
+ */
+export const ISSUE_SESSION_HEARTBEAT_INTERVAL_MS = 60_000;
+const FOREIGN_LEASE_RECLAIM_STALENESS_MS = 2 * ISSUE_SESSION_HEARTBEAT_INTERVAL_MS;
+/**
+ * Issue-session lease coordination over the `issue_sessions` lease columns.
+ * The DB row (`lease_id`, `worker_id`, `leased_until`) is the only truth —
+ * there is no in-memory mirror, so a restarted process loses no lease state
+ * (D4, core simplification plan). "Held by us" means the row carries this
+ * service's `workerId` with an unexpired `leased_until`.
+ */
 export class IssueSessionLeaseService {
     db;
     logger;
     workerId;
-    readThreadWithRetry;
     telemetry;
-    activeSessionLeases = new Map();
-    constructor(db, logger, workerId, readThreadWithRetry, telemetry = noopTelemetry) {
+    constructor(db, logger, workerId, telemetry = noopTelemetry) {
         this.db = db;
         this.logger = logger;
         this.workerId = workerId;
-        this.readThreadWithRetry = readThreadWithRetry;
         this.telemetry = telemetry;
     }
     hasLocalLease(projectId, linearIssueId) {
-        return this.getValidatedLocalLeaseId(projectId, linearIssueId) !== undefined;
+        return this.getHeldLease(projectId, linearIssueId) !== undefined;
     }
     getHeldLease(projectId, linearIssueId) {
-        const leaseId = this.getValidatedLocalLeaseId(projectId, linearIssueId);
-        if (!leaseId)
+        const session = this.db.issueSessions.getIssueSession(projectId, linearIssueId);
+        if (!session?.leaseId || session.workerId !== this.workerId || !isLeaseActive(session)) {
             return undefined;
-        return { projectId, linearIssueId, leaseId };
+        }
+        return { projectId, linearIssueId, leaseId: session.leaseId };
     }
     withHeldLease(projectId, linearIssueId, fn) {
         const lease = this.getHeldLease(projectId, linearIssueId);
         if (!lease)
             return undefined;
+        // Re-validated inside the store's transaction so the check and the
+        // guarded writes are atomic.
         return this.db.issueSessions.withIssueSessionLease(projectId, linearIssueId, lease.leaseId, () => fn(lease));
     }
     acquire(projectId, linearIssueId) {
@@ -46,7 +63,6 @@ export class IssueSessionLeaseService {
             this.emitStaleLeaseInvariantIfRunnable(projectId, linearIssueId);
             return undefined;
         }
-        this.activeSessionLeases.set(this.issueSessionLeaseKey(projectId, linearIssueId), leaseId);
         this.emitLease("lease.acquired", projectId, linearIssueId, leaseId);
         return leaseId;
     }
@@ -64,20 +80,17 @@ export class IssueSessionLeaseService {
             this.emitLease("lease.acquire_failed", projectId, linearIssueId);
             return undefined;
         }
-        this.activeSessionLeases.set(this.issueSessionLeaseKey(projectId, linearIssueId), leaseId);
         this.emitLease("lease.acquired", projectId, linearIssueId, leaseId);
         return leaseId;
     }
     claimForReconciliation(projectId, linearIssueId) {
-        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
-        if (this.activeSessionLeases.has(key)) {
-            return "owned";
-        }
         const session = this.db.issueSessions.getIssueSession(projectId, linearIssueId);
         if (!session)
             return "skip";
-        const leasedUntilMs = session.leasedUntil ? Date.parse(session.leasedUntil) : undefined;
-        if (leasedUntilMs !== undefined && Number.isFinite(leasedUntilMs) && leasedUntilMs > Date.now()) {
+        if (isLeaseActive(session)) {
+            if (session.workerId === this.workerId) {
+                return "owned";
+            }
             this.emitStaleLeaseInvariantIfRunnable(projectId, linearIssueId);
             return "skip";
         }
@@ -86,11 +99,16 @@ export class IssueSessionLeaseService {
         }
         return this.acquire(projectId, linearIssueId) ? true : "skip";
     }
-    async reclaimForeignRecoveryLeaseIfSafe(run, issue) {
-        const key = this.issueSessionLeaseKey(run.projectId, run.linearIssueId);
-        if (this.activeSessionLeases.has(key)) {
-            return false;
-        }
+    /**
+     * Post-crash recovery shortcut: take over a foreign (other-worker) lease on
+     * an issue whose active run needs recovery, without waiting for full TTL
+     * expiry. Safe purely on heartbeat staleness — post-phase-B invariants make
+     * the recovery path idempotent (settleRun is idempotent, slot-clearing has
+     * exactly one owner, recovery is detect → RunFailurePolicy → settleRun) —
+     * so no Codex thread probing is needed. A holder that has not heartbeat
+     * for 2x the heartbeat budget is presumed dead.
+     */
+    reclaimForeignRecoveryLeaseIfSafe(run, issue) {
         const session = this.db.issueSessions.getIssueSession(run.projectId, run.linearIssueId);
         if (!session?.leaseId || !session.workerId || session.workerId === this.workerId) {
             return false;
@@ -98,20 +116,12 @@ export class IssueSessionLeaseService {
         if (issue.activeRunId !== run.id) {
             return false;
         }
-        let safeToReclaim = !run.threadId;
-        if (!safeToReclaim && run.threadId) {
-            try {
-                const thread = await this.readThreadWithRetry(run.threadId, 1);
-                const latestTurn = getThreadTurns(thread).at(-1);
-                safeToReclaim = thread.status === "notLoaded"
-                    || latestTurn?.status === "interrupted"
-                    || latestTurn?.status === "completed";
-            }
-            catch {
-                safeToReclaim = true;
-            }
-        }
-        if (!safeToReclaim) {
+        const leasedUntilMs = session.leasedUntil ? Date.parse(session.leasedUntil) : Number.NaN;
+        // A lease row without a parseable leasedUntil cannot prove a live holder.
+        const heartbeatAgeMs = Number.isFinite(leasedUntilMs)
+            ? Date.now() - (leasedUntilMs - ISSUE_SESSION_LEASE_MS)
+            : Number.POSITIVE_INFINITY;
+        if (heartbeatAgeMs < FOREIGN_LEASE_RECLAIM_STALENESS_MS) {
             return false;
         }
         const leaseId = this.forceAcquire(run.projectId, run.linearIssueId);
@@ -123,6 +133,7 @@ export class IssueSessionLeaseService {
             runId: run.id,
             previousWorkerId: session.workerId,
             previousLeaseId: session.leaseId,
+            heartbeatAgeMs: Math.round(heartbeatAgeMs),
             reclaimedLeaseId: leaseId,
         }, "Reclaimed foreign issue-session lease for active-run recovery");
         emitTelemetry(this.telemetry, {
@@ -138,43 +149,29 @@ export class IssueSessionLeaseService {
         return true;
     }
     heartbeat(projectId, linearIssueId) {
-        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
-        const leaseId = this.activeSessionLeases.get(key) ?? this.db.issueSessions.getIssueSession(projectId, linearIssueId)?.leaseId;
-        if (!leaseId)
+        const session = this.db.issueSessions.getIssueSession(projectId, linearIssueId);
+        // Only this worker's lease may be renewed: extending a foreign holder's
+        // lease would let a launch proceed against a lease we do not hold.
+        if (!session?.leaseId || session.workerId !== this.workerId) {
             return false;
-        const renewed = this.db.issueSessions.renewIssueSessionLease({
+        }
+        return this.db.issueSessions.renewIssueSessionLease({
             projectId,
             linearIssueId,
-            leaseId,
+            leaseId: session.leaseId,
             leasedUntil: new Date(Date.now() + ISSUE_SESSION_LEASE_MS).toISOString(),
         });
-        if (renewed) {
-            this.activeSessionLeases.set(key, leaseId);
-            return true;
-        }
-        this.activeSessionLeases.delete(key);
-        return false;
     }
     release(projectId, linearIssueId) {
-        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
-        const leaseId = this.getValidatedLocalLeaseId(projectId, linearIssueId);
-        this.db.issueSessions.releaseIssueSessionLease(projectId, linearIssueId, leaseId);
-        this.activeSessionLeases.delete(key);
-        this.emitLease("lease.released", projectId, linearIssueId, leaseId);
-    }
-    getValidatedLocalLeaseId(projectId, linearIssueId) {
-        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
-        const leaseId = this.activeSessionLeases.get(key);
-        if (!leaseId)
-            return undefined;
-        if (this.db.issueSessions.hasActiveIssueSessionLease(projectId, linearIssueId, leaseId)) {
-            return leaseId;
+        const session = this.db.issueSessions.getIssueSession(projectId, linearIssueId);
+        const ownLeaseId = session?.workerId === this.workerId ? session.leaseId : undefined;
+        if (!ownLeaseId && session?.leaseId && isLeaseActive(session)) {
+            // An active foreign lease is not ours to clear; expired leftovers are
+            // swept by releaseExpiredIssueSessionLeases.
+            return;
         }
-        this.activeSessionLeases.delete(key);
-        return undefined;
-    }
-    issueSessionLeaseKey(projectId, linearIssueId) {
-        return `${projectId}:${linearIssueId}`;
+        this.db.issueSessions.releaseIssueSessionLease(projectId, linearIssueId, ownLeaseId);
+        this.emitLease("lease.released", projectId, linearIssueId, ownLeaseId);
     }
     emitLease(type, projectId, linearIssueId, leaseId) {
         const issue = this.db.issues.getIssue(projectId, linearIssueId);
@@ -206,3 +203,9 @@ export class IssueSessionLeaseService {
         });
     }
 }
+function isLeaseActive(session, now = Date.now()) {
+    if (!session.leaseId || !session.leasedUntil)
+        return false;
+    const leasedUntilMs = Date.parse(session.leasedUntil);
+    return Number.isFinite(leasedUntilMs) && leasedUntilMs > now;
+}

package/dist/issue-session.js

@@ -1,4 +1,3 @@
-import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
 export function deriveIssueSessionState(params) {
     if (params.factoryState === "done")
         return "done";
@@ -10,9 +9,6 @@ export function deriveIssueSessionState(params) {
         return "running";
     return "idle";
 }
-export function deriveIssueSessionWaitingReason(params) {
-    return derivePatchRelayWaitingReason(params);
-}
 export function deriveIssueSessionWakeReason(params) {
     if (params.delegatedToPatchRelay === false)
         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({

package/dist/paused-issue-state.js

@@ -1,9 +1,10 @@
 import { resolveAwaitingInputReason } from "./awaiting-input-reason.js";
+import { deriveIssueExecutionState } from "./issue-execution-state.js";
 export function isUndelegatedPausedIssue(issue) {
-    return issue.delegatedToPatchRelay === false
-        && issue.factoryState !== "done"
-        && issue.factoryState !== "failed"
-        && issue.factoryState !== "escalated";
+    return deriveIssueExecutionState({
+        delegatedToPatchRelay: issue.delegatedToPatchRelay,
+        factoryState: issue.factoryState,
+    }).kind === "undelegated";
 }
 export function isUndelegatedPausedNoPrWork(issue) {
     return isUndelegatedPausedIssue(issue)

package/dist/prompting/patchrelay.js

@@ -121,14 +121,8 @@ function summarizeRelationEntries(entries, options) {
     return lines;
 }
 function buildIssueTopology(context) {
-    const unresolvedBlockers = Array.isArray(context?.unresolvedBlockers)
-        ? context.unresolvedBlockers.filter((entry) => Boolean(entry) && typeof entry === "object")
-        : [];
-    const childIssues = Array.isArray(context?.childIssues)
-        ? context.childIssues.filter((entry) => Boolean(entry) && typeof entry === "object")
-        : Array.isArray(context?.trackedDependents)
-            ? context.trackedDependents.filter((entry) => Boolean(entry) && typeof entry === "object")
-            : [];
+    const unresolvedBlockers = context?.unresolvedBlockers ?? [];
+    const childIssues = context?.childIssues ?? context?.trackedDependents ?? [];
     if (unresolvedBlockers.length === 0 && childIssues.length === 0) {
         return [];
     }
@@ -165,14 +159,8 @@ function buildConstraints(issue, context) {
     ].join("\n");
 }
 function buildOrchestrationConstraints(context) {
-    const unresolvedBlockers = Array.isArray(context?.unresolvedBlockers)
-        ? context.unresolvedBlockers.filter((entry) => Boolean(entry) && typeof entry === "object")
-        : [];
-    const childIssues = Array.isArray(context?.childIssues)
-        ? context.childIssues.filter((entry) => Boolean(entry) && typeof entry === "object")
-        : Array.isArray(context?.trackedDependents)
-            ? context.trackedDependents.filter((entry) => Boolean(entry) && typeof entry === "object")
-            : [];
+    const unresolvedBlockers = context?.unresolvedBlockers ?? [];
+    const childIssues = context?.childIssues ?? context?.trackedDependents ?? [];
     return [
         "## Constraints",
         "",
@@ -201,13 +189,11 @@ function buildOrchestrationConstraints(context) {
     ].join("\n");
 }
 function buildHumanContextLines(context) {
-    const promptContext = typeof context?.promptContext === "string" ? context.promptContext.trim() : "";
-    const latestPrompt = typeof context?.promptBody === "string" ? context.promptBody.trim() : "";
-    const operatorPrompt = typeof context?.operatorPrompt === "string" ? context.operatorPrompt.trim() : "";
-    const userComment = typeof context?.userComment === "string" ? context.userComment.trim() : "";
-    const linearAgentActivityContext = typeof context?.linearAgentActivityContext === "string"
-        ? context.linearAgentActivityContext.trim()
-        : "";
+    const promptContext = context?.promptContext?.trim() ?? "";
+    const latestPrompt = context?.promptBody?.trim() ?? "";
+    const operatorPrompt = context?.operatorPrompt?.trim() ?? "";
+    const userComment = context?.userComment?.trim() ?? "";
+    const linearAgentActivityContext = context?.linearAgentActivityContext?.trim() ?? "";
     const lines = [];
     if (promptContext) {
         lines.push("Linear session context:", promptContext, "");
@@ -235,35 +221,28 @@ function resolveRequestedChangesMode(runType, context) {
         : "address_review_feedback";
 }
 function readReviewFixComments(context) {
-    const raw = context?.reviewComments;
-    if (!Array.isArray(raw)) {
-        return [];
-    }
     const comments = [];
-    for (const entry of raw) {
-        if (!entry || typeof entry !== "object")
-            continue;
-        const record = entry;
-        const body = typeof record.body === "string" ? record.body.trim() : "";
+    for (const record of context?.reviewComments ?? []) {
+        const body = record.body?.trim() ?? "";
         if (!body)
             continue;
         comments.push({
             body,
-            ...(typeof record.path === "string" ? { path: record.path } : {}),
-            ...(typeof record.line === "number" ? { line: record.line } : {}),
-            ...(typeof record.side === "string" ? { side: record.side } : {}),
-            ...(typeof record.startLine === "number" ? { startLine: record.startLine } : {}),
-            ...(typeof record.startSide === "string" ? { startSide: record.startSide } : {}),
-            ...(typeof record.url === "string" ? { url: record.url } : {}),
-            ...(typeof record.authorLogin === "string" ? { authorLogin: record.authorLogin } : {}),
+            ...(record.path !== undefined ? { path: record.path } : {}),
+            ...(record.line !== undefined ? { line: record.line } : {}),
+            ...(record.side !== undefined ? { side: record.side } : {}),
+            ...(record.startLine !== undefined ? { startLine: record.startLine } : {}),
+            ...(record.startSide !== undefined ? { startSide: record.startSide } : {}),
+            ...(record.url !== undefined ? { url: record.url } : {}),
+            ...(record.authorLogin !== undefined ? { authorLogin: record.authorLogin } : {}),
         });
     }
     return comments;
 }
 function buildStructuredReviewContext(context) {
-    const reviewId = typeof context?.reviewId === "number" ? context.reviewId : undefined;
-    const reviewCommitId = typeof context?.reviewCommitId === "string" ? context.reviewCommitId : undefined;
-    const reviewUrl = typeof context?.reviewUrl === "string" ? context.reviewUrl : undefined;
+    const reviewId = context?.reviewId;
+    const reviewCommitId = context?.reviewCommitId;
+    const reviewUrl = context?.reviewUrl;
     const reviewComments = readReviewFixComments(context);
     const degraded = context?.reviewContextDegraded === true;
     if (!degraded && !reviewId && !reviewCommitId && !reviewUrl && reviewComments.length === 0) {
@@ -271,9 +250,8 @@ function buildStructuredReviewContext(context) {
     }
     const lines = ["## Structured Review Context", ""];
     if (degraded) {
-        const reason = typeof context?.reviewContextDegradedReason === "string" && context.reviewContextDegradedReason.trim()
-            ? context.reviewContextDegradedReason.trim()
-            : "GitHub requested-changes context could not be refreshed before launch.";
+        const reason = context?.reviewContextDegradedReason?.trim()
+            || "GitHub requested-changes context could not be refreshed before launch.";
         lines.push("GitHub review context refresh: degraded", reason, "Do not assume cached review details are current. Re-read the PR review in GitHub before making review-fix changes.");
     }
     if (reviewId !== undefined)
@@ -311,17 +289,15 @@ function buildRequestedChangesContext(runType, context) {
         lines.push("Branch upkeep is required on the existing PR branch.", "Goal: restore merge readiness on the current branch. Push a newer head only when the work actually changes the diff against the base; do not republish a patch-id-equivalent head.");
     }
     else {
-        const reviewer = typeof context?.reviewerName === "string" ? context.reviewerName : undefined;
-        const reviewBody = typeof context?.reviewBody === "string" ? context.reviewBody.trim() : "";
+        const reviewer = context?.reviewerName;
+        const reviewBody = context?.reviewBody?.trim() ?? "";
         lines.push("Requested changes on the existing PR branch.", "Goal: restore review readiness on the current PR branch. Push a newer head only when the fix actually changes the diff; if the reviewer-pass produces only comments, test wording, or PR-body changes, edit the PR body via `gh pr edit` instead.", "Address the real concern behind the feedback and verify nearby invariants in the touched flow before you publish.", "For each review comment, identify the resource, epoch, or token it touches (e.g. session, capture, route, persistence handle, in-flight turn id), enumerate the other transitions that share that same resource, and verify each one before pushing — not just the exact path called out. If you find an adjacent transition that violates the same invariant, fix it in this iteration rather than waiting for the reviewer to surface it next round.", reviewer ? `Reviewer: ${reviewer}` : "", reviewBody ? `Review summary:\n${reviewBody}` : "");
         appendStructuredReviewContext(lines, context);
     }
     return lines.join("\n").trim();
 }
 function buildCiRepairContext(context) {
-    const snapshot = context?.ciSnapshot && typeof context.ciSnapshot === "object"
-        ? context.ciSnapshot
-        : undefined;
+    const snapshot = context?.ciSnapshot;
     return [
         "Settled CI failure on the existing PR branch.",
         "Goal: restore CI readiness and push a branch that is likely to pass the next full CI run.",
@@ -346,31 +322,26 @@ function buildCiRepairContext(context) {
     ].filter(Boolean).join("\n");
 }
 function appendQueueRepairContext(lines, context) {
-    const queueContext = context?.mergeQueueContext;
-    if (!queueContext || typeof queueContext !== "object") {
+    const record = context?.mergeQueueContext;
+    if (!record) {
         return;
     }
-    const record = queueContext;
-    const conflictingFiles = Array.isArray(record.conflictingFiles)
-        ? record.conflictingFiles.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
-        : [];
-    const operatorHints = Array.isArray(record.operatorHints)
-        ? record.operatorHints.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
-        : [];
+    const conflictingFiles = (record.conflictingFiles ?? []).filter((entry) => entry.trim().length > 0);
+    const operatorHints = (record.operatorHints ?? []).filter((entry) => entry.trim().length > 0);
     lines.push("## Merge Queue Context", "");
-    if (typeof record.baseBranch === "string") {
+    if (record.baseBranch !== undefined) {
         lines.push(`Base branch: ${record.baseBranch}`);
     }
-    if (typeof record.baseSha === "string") {
+    if (record.baseSha !== undefined) {
         lines.push(`Base SHA at eviction: ${record.baseSha}`);
     }
-    if (typeof record.mergeCommitSha === "string") {
+    if (record.mergeCommitSha !== undefined) {
         lines.push(`Synthetic merge commit SHA: ${record.mergeCommitSha}`);
     }
-    if (typeof record.checkRunUrl === "string") {
+    if (record.checkRunUrl !== undefined) {
         lines.push(`Steward check run: ${record.checkRunUrl}`);
     }
-    if (typeof record.incidentSummary === "string") {
+    if (record.incidentSummary !== undefined) {
         lines.push(`Steward summary: ${record.incidentSummary}`);
     }
     if (conflictingFiles.length > 0) {
@@ -391,11 +362,9 @@ function buildQueueRepairContext(context) {
 }
 function buildFollowUpContextLines(issue, runType, context) {
     const prContext = derivePrDisplayContext(issue);
-    const wakeReason = typeof context?.wakeReason === "string" ? context.wakeReason : undefined;
-    const followUps = Array.isArray(context?.followUps) ? context.followUps : [];
-    const followUpLines = followUps
-        .filter((entry) => Boolean(entry) && typeof entry === "object")
-        .map((entry) => `${String(entry.type ?? "follow_up")} from ${String(entry.author ?? "unknown")}: ${String(entry.text ?? "").trim()}`.trim())
+    const wakeReason = context?.wakeReason;
+    const followUpLines = (context?.followUps ?? [])
+        .map((entry) => `${entry.type ?? "follow_up"} from ${entry.author ?? "unknown"}: ${(entry.text ?? "").trim()}`.trim())
         .filter((line) => !line.endsWith(":"));
     const lines = [];
     const turnReason = wakeReason === "direct_reply"
@@ -418,17 +387,15 @@ function buildFollowUpContextLines(issue, runType, context) {
                                         ? "A human follow-up comment arrived after the previous turn."
                                         : `Continue the existing ${runType} run from the latest issue state.`;
     lines.push(`Turn reason: ${turnReason}`);
-    if (wakeReason === "completion_check_continue" && typeof context?.completionCheckSummary === "string" && context.completionCheckSummary.trim()) {
+    if (wakeReason === "completion_check_continue" && context?.completionCheckSummary?.trim()) {
         lines.push(`Completion check summary: ${context.completionCheckSummary.trim()}`);
     }
     if (context?.preserveDirtyWorktree === true) {
         lines.push("", "Unpublished local work:", "PatchRelay detected that the previous repair turn ended with uncommitted changes in this worktree.", "Do not reset, clean, stash-drop, or otherwise discard the current worktree. Inspect the existing local diff, keep the intended in-scope repair, then commit and push a fresh PR head.");
-        if (typeof context.dirtyWorktreeSummary === "string" && context.dirtyWorktreeSummary.trim()) {
+        if (context.dirtyWorktreeSummary?.trim()) {
             lines.push(`Dirty worktree summary: ${context.dirtyWorktreeSummary.trim()}`);
         }
-        const changedPaths = Array.isArray(context.dirtyWorktreeChangedPaths)
-            ? context.dirtyWorktreeChangedPaths.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
-            : [];
+        const changedPaths = (context.dirtyWorktreeChangedPaths ?? []).filter((entry) => entry.trim().length > 0);
         if (changedPaths.length > 0) {
             lines.push("Changed paths:");
             changedPaths.slice(0, 12).forEach((entry) => lines.push(`- ${entry}`));
@@ -443,16 +410,16 @@ function buildFollowUpContextLines(issue, runType, context) {
     }
     if (context?.replacementPrRequired === true) {
         lines.push("", "Previous PR facts:");
-        if (typeof context.previousPrNumber === "number") {
+        if (context.previousPrNumber !== undefined) {
             lines.push(`Previous PR: #${context.previousPrNumber} (replacement PR needed)`);
         }
-        if (typeof context.previousPrUrl === "string") {
+        if (context.previousPrUrl !== undefined) {
             lines.push(`Previous PR URL: ${context.previousPrUrl}`);
         }
-        if (typeof context.previousPrState === "string") {
+        if (context.previousPrState !== undefined) {
             lines.push(`Previous PR state: ${context.previousPrState}`);
         }
-        if (typeof context.previousPrHeadSha === "string") {
+        if (context.previousPrHeadSha !== undefined) {
             lines.push(`Previous PR head SHA: ${context.previousPrHeadSha}`);
         }
         lines.push("Create a fresh replacement PR for the new requested changes; do not mutate or republish the completed PR.");
@@ -476,7 +443,7 @@ function buildFollowUpContextLines(issue, runType, context) {
                             : "";
         lines.push("", prHeading, `Fact freshness: ${context?.githubFactsFresh === true
             ? "refreshed immediately before this turn was created."
-            : "may now be stale; refresh before making irreversible decisions."}`, prLine, issue.prHeadSha ? `Current relevant head SHA: ${issue.prHeadSha}` : "", issue.prReviewState ? `Current review state: ${issue.prReviewState}` : "", typeof context?.mergeStateStatus === "string" ? `Merge state against ${String(context?.baseBranch ?? "main")}: ${String(context.mergeStateStatus)}` : "");
+            : "may now be stale; refresh before making irreversible decisions."}`, prLine, issue.prHeadSha ? `Current relevant head SHA: ${issue.prHeadSha}` : "", issue.prReviewState ? `Current review state: ${issue.prReviewState}` : "", context?.mergeStateStatus !== undefined ? `Merge state against ${context?.baseBranch ?? "main"}: ${context.mergeStateStatus}` : "");
     }
     return lines.filter(Boolean);
 }
@@ -670,7 +637,7 @@ function shouldBuildFollowUpPrompt(runType, context) {
         return true;
     if (runType !== "implementation")
         return true;
-    const wakeReason = typeof context?.wakeReason === "string" ? context.wakeReason : undefined;
+    const wakeReason = context?.wakeReason;
     return Boolean(wakeReason && wakeReason !== "delegated");
 }
 export function resolvePromptLayers(config, runType) {

package/dist/queue-health-monitor.js

@@ -1,5 +1,6 @@
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { buildRepairWakeDedupeKey } from "./reactive-wake-keys.js";
+import { serializeRunContext } from "./run-context.js";
 import { execCommand } from "./utils.js";
 const WRITER = "queue-health-monitor";
 const QUEUE_HEALTH_GRACE_MS = 120_000;
@@ -10,8 +11,8 @@ const QUEUE_HEALTH_PROBE_FAILURE_COOLDOWN_MS = 300_000;
 const IN_REVIEW_STUCK_THRESHOLD_MS = 30 * 60 * 1000;
 const IN_REVIEW_STUCK_FEED_COOLDOWN_MS = 30 * 60 * 1000;
 function isDuplicateProbe(issue, context) {
-    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
-    const headSha = typeof context?.failureHeadSha === "string" ? context.failureHeadSha : undefined;
+    const signature = context?.failureSignature;
+    const headSha = context?.failureHeadSha;
     if (!signature)
         return false;
     if (context?.requiresFreshHead === true)
@@ -176,7 +177,7 @@ export class QueueHealthMonitor {
             const probed = probedCommit.outcome === "applied" ? probedCommit.issue : issue;
             this.advancer.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
                 eventType: "merge_steward_incident",
-                eventJson: JSON.stringify(pendingRunContext),
+                eventJson: serializeRunContext(pendingRunContext, "queue health repair context"),
                 dedupeKey: buildRepairWakeDedupeKey({
                     scope: "queue_health",
                     runType: "queue_repair",