patchrelay 0.78.0 → 0.79.0

package/dist/run-context.js

@@ -0,0 +1,382 @@
+import { z } from "zod";
+// Plan §D1: the one typed schema for the run context object — the bag that is
+// (a) stored in `issues.pending_run_context_json` (legacy pending-wake path,
+//     read back by RunWakePlanner.materializeLegacyPendingWake),
+// (b) carried in session-event `event_json` payloads for wake events and
+//     merged into the wake plan by deriveSessionWakePlan, and
+// (c) passed around in memory as `context` / `effectiveContext` /
+//     `pendingRunContext` until it reaches the prompt builder and launcher.
+//
+// Every known field is typed strictly so a mistyped field fails loudly at the
+// parse boundary. Unknown keys are deliberately TOLERATED (loose object), not
+// rejected, because:
+// - existing DB rows contain contexts written by older PatchRelay versions
+//   whose field sets we no longer produce (e.g. `mergeQueueContext`,
+//   `userComment`, `operatorPrompt` below survive only as legacy reads), and
+// - deriveSessionWakePlan merges whole event payloads into the context via
+//   Object.assign, so producer-side extra keys flow through by design.
+// The static `RunContext` type intentionally has NO index signature (it is
+// inferred from a non-loose mirror of the same shape), so compile-time access
+// to undeclared fields is an error even though runtime parsing passes unknown
+// keys through. NESTED objects (ciSnapshot, incidentContext, reviewComments
+// entries, ...) use plain z.object — unknown nested keys are stripped at the
+// boundary instead of passed through: they are leaf display data, every field
+// any consumer reads is declared here, and a single definition keeps the
+// static type free of index signatures so producer-side `satisfies RunContext`
+// checks stay sound.
+/** Entry of `followUps`, assembled by deriveSessionWakePlan from
+ * direct_reply / followup_prompt / followup_comment / operator_prompt event
+ * payloads; consumed by prompting/patchrelay.ts buildFollowUpContextLines. */
+const followUpEntryShape = {
+    type: z.string().optional(),
+    text: z.string().optional(),
+    author: z.string().optional(),
+};
+/** Inline review comment captured from GitHub. Produced by
+ * github-webhook-reactive-run.ts fetchReviewCommentsForEvent and
+ * reactive-run-policy.ts hydrateRequestedChangesContext (remote-pr-review.ts);
+ * consumed by prompting/patchrelay.ts readReviewFixComments and
+ * run-orchestrator.ts (review round activity comment count). */
+const reviewCommentShape = {
+    id: z.number().optional(),
+    body: z.string().optional(),
+    path: z.string().optional(),
+    line: z.number().optional(),
+    side: z.string().optional(),
+    startLine: z.number().optional(),
+    startSide: z.string().optional(),
+    commitId: z.string().optional(),
+    url: z.string().optional(),
+    diffHunk: z.string().optional(),
+    authorLogin: z.string().optional(),
+};
+/** Related-issue summary used by the issue-topology prompt sections. Produced
+ * by run-orchestrator.ts buildRelatedIssueContext; consumed by
+ * prompting/patchrelay.ts summarizeRelationEntries. */
+const relatedIssueShape = {
+    linearIssueId: z.string().optional(),
+    issueKey: z.string().optional(),
+    title: z.string().optional(),
+    stateName: z.string().optional(),
+    stateType: z.string().optional(),
+    factoryState: z.string().optional(),
+    currentLinearState: z.string().optional(),
+    delegatedToPatchRelay: z.boolean().optional(),
+    hasOpenPr: z.boolean().optional(),
+};
+/** One check inside a CI snapshot (github-failure-context.ts
+ * mapCiSnapshotCheck). */
+const ciSnapshotCheckShape = {
+    name: z.string().optional(),
+    status: z.string().optional(),
+    conclusion: z.string().optional(),
+    detailsUrl: z.string().optional(),
+    summary: z.string().optional(),
+};
+/** Settled CI snapshot. Produced by github-failure-context.ts
+ * buildCiSnapshotFromChecks (attached to settled_red_ci payloads by
+ * github-webhook-reactive-run.ts and to implicit ci_repair wakes by
+ * workflow-wake-resolver.ts); consumed by prompting/patchrelay.ts
+ * buildCiRepairContext. */
+const ciSnapshotShape = {
+    headSha: z.string().optional(),
+    gateCheckName: z.string().optional(),
+    gateCheckStatus: z.string().optional(),
+    settledAt: z.string().optional(),
+    capturedAt: z.string().optional(),
+    failedChecks: z.array(z.object(ciSnapshotCheckShape)).optional(),
+    checks: z.array(z.object(ciSnapshotCheckShape)).optional(),
+};
+/** Queue-eviction incident detail (merge-queue-incident.ts
+ * QueueEvictionIncidentContext), parsed from the steward's check-run output. */
+const queueIncidentContextShape = {
+    version: z.number().optional(),
+    failureClass: z.string().optional(),
+    baseSha: z.string().optional(),
+    prHeadSha: z.string().optional(),
+    queuePosition: z.number().optional(),
+    baseBranch: z.string().optional(),
+    branch: z.string().optional(),
+    issueKey: z.string().nullable().optional(),
+    conflictFiles: z.array(z.string()).optional(),
+    failedChecks: z.array(z.object({
+        name: z.string().optional(),
+        conclusion: z.string().optional(),
+        url: z.string().optional(),
+    })).optional(),
+    retryHistory: z.array(z.object({
+        at: z.string().optional(),
+        baseSha: z.string().optional(),
+        outcome: z.string().optional(),
+    })).optional(),
+};
+/** LEGACY: merge-queue context block read by prompting/patchrelay.ts
+ * appendQueueRepairContext. No current producer writes this field — it only
+ * appears in contexts persisted by older versions, so it stays in the schema
+ * for legacy-row compatibility. */
+const mergeQueueContextShape = {
+    baseBranch: z.string().optional(),
+    baseSha: z.string().optional(),
+    mergeCommitSha: z.string().optional(),
+    checkRunUrl: z.string().optional(),
+    incidentSummary: z.string().optional(),
+    conflictingFiles: z.array(z.string()).optional(),
+    operatorHints: z.array(z.string()).optional(),
+};
+const runContextShape = {
+    // ── Wake framing ──────────────────────────────────────────────────
+    /** Why this wake exists. Produced by deriveSessionWakePlan (and by
+     * branch-upkeep context builders, operator-retry-event); consumed by
+     * prompting/patchrelay.ts (turn reason, follow-up prompt selection). Kept a
+     * free string: the value set spans wake reasons and event types and legacy
+     * rows carry values we no longer emit. */
+    wakeReason: z.string().optional(),
+    /** Requested run type inside a `delegated` / `completion_check_continue`
+     * payload. Free string because legacy payloads carry removed run types
+     * (e.g. "main_repair"); consumers narrow via parseRunType and fall back to
+     * "implementation". */
+    runType: z.string().optional(),
+    /** Producer tag ("operator_retry", "queue_health_monitor",
+     * "idle_reconciliation", ...). Produced by operator-retry-event.ts,
+     * queue-health-monitor.ts, idle-reconciliation.ts; diagnostic only. */
+    source: z.string().optional(),
+    // ── Human / orchestration context ─────────────────────────────────
+    /** Prompt guidance. Produced by buildBranchUpkeepContext /
+     * buildReviewFixBranchUpkeepContext, operator-retry-event.ts,
+     * queue-health-monitor.ts, webhooks/desired-stage-recorder.ts; consumed by
+     * prompting/patchrelay.ts buildHumanContextLines. */
+    promptContext: z.string().optional(),
+    /** Latest human instruction body, from `delegated` payloads
+     * (webhooks/desired-stage-recorder.ts); consumed by buildHumanContextLines. */
+    promptBody: z.string().optional(),
+    /** LEGACY: read by prompting/patchrelay.ts and
+     * linear-agent-activity-recovery.ts; no current producer. */
+    operatorPrompt: z.string().optional(),
+    /** LEGACY: read by prompting/patchrelay.ts and
+     * linear-agent-activity-recovery.ts; no current producer. */
+    userComment: z.string().optional(),
+    /** Recovered Linear agent-activity transcript. Produced by
+     * linear-agent-activity-recovery.ts summarizeLinearAgentActivities; consumed
+     * by prompting/patchrelay.ts buildHumanContextLines. */
+    linearAgentActivityContext: z.string().optional(),
+    /** Companion count for linearAgentActivityContext (same producer). */
+    linearAgentActivityCount: z.number().optional(),
+    /** Follow-up messages collected by deriveSessionWakePlan; consumed by
+     * prompting/patchrelay.ts and linear-agent-activity-recovery.ts. */
+    followUps: z.array(z.object(followUpEntryShape)).optional(),
+    /** Set by deriveSessionWakePlan when followUps is non-empty; consumed by
+     * prompting/patchrelay.ts shouldBuildFollowUpPrompt. */
+    followUpMode: z.boolean().optional(),
+    /** Produced by deriveSessionWakePlan; consumed by run-launcher.ts
+     * shouldCompactThread. */
+    followUpCount: z.number().optional(),
+    /** Produced by deriveSessionWakePlan for direct_reply events. */
+    directReplyMode: z.boolean().optional(),
+    // ── Completion-check continuation ─────────────────────────────────
+    /** Produced by deriveSessionWakePlan for completion_check_continue events. */
+    completionCheckMode: z.boolean().optional(),
+    /** Produced by deriveSessionWakePlan (from the event payload `summary`);
+     * consumed by prompting/patchrelay.ts buildFollowUpContextLines. */
+    completionCheckSummary: z.string().optional(),
+    // ── Dirty-worktree continuation (run-finalizer.ts
+    //    continueDirtyRepairWorktree → completion_check_continue payload) ──
+    /** Consumed by run-launcher.ts shouldPreserveDirtyWorktreeBeforeLaunch and
+     * prompting/patchrelay.ts buildFollowUpContextLines. */
+    preserveDirtyWorktree: z.boolean().optional(),
+    dirtyWorktreeSummary: z.string().optional(),
+    dirtyWorktreeChangedPaths: z.array(z.string()).optional(),
+    dirtyWorktreeMergeInProgress: z.boolean().optional(),
+    // ── Replacement-PR facts (agent-input-service payloads merged by
+    //    deriveSessionWakePlan; consumed by prompting/patchrelay.ts) ──
+    replacementPrRequired: z.boolean().optional(),
+    previousPrNumber: z.number().optional(),
+    previousPrUrl: z.string().optional(),
+    previousPrState: z.string().optional(),
+    previousPrHeadSha: z.string().optional(),
+    // ── Requested-changes / review fix ────────────────────────────────
+    /** Coalescing identity for review_changes_requested wakes. Produced by
+     * buildRequestedChangesWakeIdentity callers (run-wake-planner.ts,
+     * github-webhook-reactive-run.ts, operator-retry-event.ts,
+     * idle-reconciliation.ts); consumed by reactive-wake-keys.ts
+     * readRequestedChangesCoalesceKey for event coalescing. */
+    requestedChangesCoalesceKey: z.string().optional(),
+    requestedChangesHeadSha: z.string().optional(),
+    /** "branch_upkeep" is the only value ever produced (idle-reconciliation-
+     * helpers.ts buildBranchUpkeepContext, reactive-pr-state.ts
+     * buildReviewFixBranchUpkeepContext, run-failure-policy.ts); consumed by
+     * run-launcher.ts, run-failure-policy.ts resolveRetryRunType and
+     * prompting/patchrelay.ts resolveRequestedChangesMode. */
+    reviewFixMode: z.enum(["branch_upkeep"]).optional(),
+    /** Same producers/consumers as reviewFixMode (plus
+     * review_changes_requested payloads from operator-retry-event.ts and
+     * deriveSessionWakePlan branch selection). */
+    branchUpkeepRequired: z.boolean().optional(),
+    /** GitHub review id. Produced by github-webhook-reactive-run.ts and
+     * reactive-run-policy.ts hydrateRequestedChangesContext; consumed by
+     * prompting/patchrelay.ts buildStructuredReviewContext. */
+    reviewId: z.number().optional(),
+    reviewCommitId: z.string().optional(),
+    reviewUrl: z.string().optional(),
+    reviewerName: z.string().optional(),
+    reviewBody: z.string().optional(),
+    reviewComments: z.array(z.object(reviewCommentShape)).optional(),
+    /** Produced by reactive-run-policy.ts hydrateRequestedChangesContext. */
+    reviewContextStatus: z.enum(["fresh", "degraded"]).optional(),
+    reviewContextDegraded: z.boolean().optional(),
+    reviewContextDegradedReason: z.string().optional(),
+    /** Produced by reactive-run-policy.ts hydrateRequestedChangesContext. */
+    currentPrHeadSha: z.string().optional(),
+    // ── Failure provenance (CI / queue repair) ────────────────────────
+    /** Free-form failure tag: "queue_eviction" (merge-queue-incident.ts),
+     * GitHubFailureSource values (idle-reconciliation-helpers.ts
+     * buildFailureContext), "queue_eviction_missed" / "preemptive_conflict"
+     * (queue-health-monitor.ts), "merge_conflict_detected"
+     * (idle-reconciliation.ts); consumed by prompting/patchrelay.ts. */
+    failureReason: z.string().optional(),
+    failureSignature: z.string().optional(),
+    failureHeadSha: z.string().optional(),
+    /** Legacy alias for failureHeadSha still consulted by run-launcher.ts,
+     * run-orchestrator.ts and idle-reconciliation-helpers.ts
+     * isDuplicateRepairAttempt; also set by reactive-run-policy.ts
+     * hydrateRequestedChangesContext (current PR head). */
+    headSha: z.string().optional(),
+    /** Produced by buildBranchUpkeepContext / buildReviewFixBranchUpkeepContext
+     * (head that was failing/dirty at wake time). */
+    failingHeadSha: z.string().optional(),
+    // GitHubFailureContext fields (github-failure-context.ts), spread into
+    // contexts by buildFailureContext / workflow-wake-resolver.ts /
+    // operator-retry-event.ts; consumed by prompting/patchrelay.ts.
+    checkName: z.string().optional(),
+    checkUrl: z.string().optional(),
+    checkDetailsUrl: z.string().optional(),
+    jobName: z.string().optional(),
+    stepName: z.string().optional(),
+    summary: z.string().optional(),
+    annotations: z.array(z.string()).optional(),
+    workflowRunId: z.number().optional(),
+    workflowName: z.string().optional(),
+    repoFullName: z.string().optional(),
+    capturedAt: z.string().optional(),
+    /** Check classification from github-webhook-failure-context.ts
+     * resolveGitHubCheckClass, attached to settled_red_ci payloads. */
+    checkClass: z.string().optional(),
+    /** See ciSnapshotShape. */
+    ciSnapshot: z.object(ciSnapshotShape).optional(),
+    // ── Queue repair (merge-queue-incident.ts QueueRepairContext) ─────
+    incidentId: z.string().optional(),
+    incidentUrl: z.string().optional(),
+    incidentTitle: z.string().optional(),
+    incidentSummary: z.string().optional(),
+    incidentContext: z.object(queueIncidentContextShape).optional(),
+    /** LEGACY (see mergeQueueContextShape). */
+    mergeQueueContext: z.object(mergeQueueContextShape).optional(),
+    queuePosition: z.number().optional(),
+    /** Force a fresh PR head SHA on queue repair. Produced by
+     * queue-health-monitor.ts and operator-retry-event.ts; consumed by
+     * prompting/patchrelay.ts buildPublicationContract and
+     * queue-health-monitor.ts isDuplicateProbe. */
+    requiresFreshHead: z.boolean().optional(),
+    // ── Branch upkeep facts ───────────────────────────────────────────
+    /** Produced by buildBranchUpkeepContext / buildReviewFixBranchUpkeepContext;
+     * consumed by prompting/patchrelay.ts buildFollowUpContextLines. */
+    mergeStateStatus: z.string().optional(),
+    baseBranch: z.string().optional(),
+    /** Set when GitHub facts were refreshed immediately before launch;
+     * consumed by prompting/patchrelay.ts (fact-freshness line). */
+    githubFactsFresh: z.boolean().optional(),
+    // ── Issue topology (implementation coordination context) ──────────
+    /** Produced by run-orchestrator.ts buildRelatedIssueContext; consumed by
+     * prompting/patchrelay.ts buildIssueTopology / orchestration constraints. */
+    unresolvedBlockers: z.array(z.object(relatedIssueShape)).optional(),
+    childIssues: z.array(z.object(relatedIssueShape)).optional(),
+    /** LEGACY alias of childIssues, still read by prompting/patchrelay.ts. */
+    trackedDependents: z.array(z.object(relatedIssueShape)).optional(),
+    // ── Child-event facts (orchestration-parent-wake.ts payloads merged by
+    //    deriveSessionWakePlan for child_changed / child_delivered /
+    //    child_regressed) ──
+    childIssueId: z.string().optional(),
+    childIssueKey: z.string().optional(),
+    childTitle: z.string().optional(),
+    factoryState: z.string().optional(),
+    currentLinearState: z.string().optional(),
+    prNumber: z.number().optional(),
+    prState: z.string().optional(),
+    changeKind: z.string().optional(),
+};
+// Type source: no index signature, so reading an undeclared field is a
+// compile-time error at every consumer.
+const runContextTypeSchema = z.object(runContextShape);
+// Parse source: tolerates unknown keys (legacy rows / merged event payloads —
+// see module comment) while still failing loudly on mistyped known fields.
+export const runContextSchema = z.looseObject(runContextShape);
+export class RunContextParseError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "RunContextParseError";
+    }
+}
+/**
+ * Validate an already-parsed value as a run context. FAILS LOUDLY
+ * (RunContextParseError) on non-object values or mistyped known fields —
+ * that is the point of D1; callers at legacy-row boundaries may catch,
+ * warn, and treat the context as absent.
+ */
+export function parseRunContextValue(value, where = "run context") {
+    const result = runContextSchema.safeParse(value);
+    if (!result.success) {
+        throw new RunContextParseError(`Invalid ${where}: ${result.error.issues
+            .map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`)
+            .join("; ")}`, { cause: result.error });
+    }
+    return result.data;
+}
+/**
+ * Parse a stored run-context JSON string. Returns undefined for
+ * null/undefined/empty input. FAILS LOUDLY (RunContextParseError) on
+ * malformed JSON or schema violations — no silent fallback.
+ */
+export function parseRunContext(json, where = "run context") {
+    if (json === null || json === undefined || json.trim() === "")
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch (error) {
+        throw new RunContextParseError(`Malformed ${where} JSON: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    return parseRunContextValue(parsed, where);
+}
+/**
+ * Boundary helper for sites that ingest possibly-old DB rows: parse loudly,
+ * but on failure report through `warn` and degrade to "no context" instead of
+ * unwinding the caller. The parse itself never silently coerces.
+ */
+export function parseRunContextOrWarn(json, warn, where = "run context") {
+    try {
+        return parseRunContext(json, where);
+    }
+    catch (error) {
+        warn(error instanceof Error ? error.message : String(error));
+        return undefined;
+    }
+}
+/**
+ * Non-throwing variant for boundaries inside the persistence layer where no
+ * logger is plumbed (workflow-wake-resolver assembling implicit wake contexts
+ * from reconciliation columns): a value the schema rejects degrades to
+ * "no context", which was already the legacy behavior for malformed JSON in
+ * those columns. Everywhere a logger exists, prefer parseRunContextOrWarn so
+ * the failure is at least observable.
+ */
+export function tryParseRunContextValue(value) {
+    const result = runContextSchema.safeParse(value);
+    return result.success ? result.data : undefined;
+}
+/**
+ * Serialize a run context for storage. Round-trips through the schema so
+ * writers cannot persist a shape the parser would reject.
+ */
+export function serializeRunContext(context, where = "run context") {
+    return JSON.stringify(parseRunContextValue(context, where));
+}

package/dist/run-failure-policy.js

@@ -2,6 +2,7 @@ import { buildRunFailureActivity } from "./linear-session-reporting.js";
 import { getRemainingZombieRecoveryDelayMs, getZombieRecoveryBudget } from "./run-budgets.js";
 import { resolvePostRunFactoryState } from "./run-completion-policy.js";
 import { isRequestedChangesRunType } from "./reactive-pr-state.js";
+import { serializeRunContext } from "./run-context.js";
 import { settleRun } from "./run-settlement.js";
 const WRITER = "run-failure-policy";
 // Roll back the attempt counter consumed by the interrupted run and clear the
@@ -431,7 +432,7 @@ export class RunFailurePolicy {
                     projectId: run.projectId,
                     linearIssueId: run.linearIssueId,
                     pendingRunType: retryRunType,
-                    pendingRunContextJson: retryContext ? JSON.stringify(retryContext) : null,
+                    pendingRunContextJson: retryContext ? serializeRunContext(retryContext, "requested-changes retry context") : null,
                 },
             });
             this.feed?.publish({

package/dist/run-finalizer.js

@@ -1,3 +1,5 @@
+import { parseIssueSessionEventOrWarn } from "./issue-session-events.js";
+import { assertNever } from "./utils.js";
 import { CLEARED_FAILURE_PROVENANCE } from "./failure-provenance.js";
 import { buildStageReport, countEventMethods } from "./run-reporting.js";
 import { buildRunCompletedActivity, buildRunFailureActivity } from "./linear-session-reporting.js";
@@ -8,17 +10,6 @@ import { inspectGitWorktreeStatus, isRepairRunType } from "./git-worktree-status
 import { buildRunOutcomeSummary } from "./run-outcome-summary.js";
 import { settleRun } from "./run-settlement.js";
 const WRITER = "run-finalizer";
-function parseEventJson(eventJson) {
-    if (!eventJson)
-        return undefined;
-    try {
-        const parsed = JSON.parse(eventJson);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 function buildRunSummaryJson(report, outcomeSummary) {
     return JSON.stringify({
         latestAssistantMessage: report.assistantMessages.at(-1) ?? null,
@@ -31,15 +22,16 @@ function summarizePromptDeliveryEvents(events, run) {
     let delivered = 0;
     let failed = 0;
     for (const event of events) {
-        if (event.eventType !== "prompt_delivered")
+        // Boundary over DB rows: a malformed payload degrades to "not counted".
+        const typed = parseIssueSessionEventOrWarn(event);
+        if (typed?.eventType !== "prompt_delivered")
             continue;
-        const payload = parseEventJson(event.eventJson);
-        if (payload?.runId !== run.id)
+        if (typed.payload?.runId !== run.id)
             continue;
-        if (payload.status === "delivered") {
+        if (typed.payload.status === "delivered") {
             delivered += 1;
         }
-        else if (payload.status === "delivery_failed") {
+        else if (typed.payload.status === "delivery_failed") {
             failed += 1;
         }
     }
@@ -94,32 +86,56 @@ export class RunFinalizer {
             ...(params.latestAssistantSummary ? { latestAssistantSummary: params.latestAssistantSummary } : {}),
         };
         const wakeEvent = this.resolveConsumedWakeEvent(params.run);
-        const payload = parseEventJson(wakeEvent?.eventJson);
-        if (!wakeEvent || !payload) {
+        if (!wakeEvent) {
             return facts;
         }
-        switch (wakeEvent.eventType) {
+        // Boundary over DB rows: a malformed wake payload degrades to bare facts.
+        const typed = parseIssueSessionEventOrWarn(wakeEvent, (message) => this.logger.warn({ runId: params.run.id, eventId: wakeEvent.id }, message));
+        if (!typed?.payload) {
+            return facts;
+        }
+        switch (typed.eventType) {
             case "review_changes_requested":
                 return {
                     ...facts,
-                    ...(typeof payload.reviewerName === "string" ? { reviewerName: payload.reviewerName } : {}),
-                    ...(typeof payload.reviewBody === "string" ? { reviewSummary: payload.reviewBody } : {}),
+                    ...(typed.payload.reviewerName !== undefined ? { reviewerName: typed.payload.reviewerName } : {}),
+                    ...(typed.payload.reviewBody !== undefined ? { reviewSummary: typed.payload.reviewBody } : {}),
                 };
             case "settled_red_ci":
                 return {
                     ...facts,
-                    ...(typeof payload.jobName === "string"
-                        ? { failingCheckName: payload.jobName }
-                        : typeof payload.checkName === "string" ? { failingCheckName: payload.checkName } : {}),
-                    ...(typeof payload.summary === "string" ? { failureSummary: payload.summary } : {}),
+                    ...(typed.payload.jobName !== undefined
+                        ? { failingCheckName: typed.payload.jobName }
+                        : typed.payload.checkName !== undefined ? { failingCheckName: typed.payload.checkName } : {}),
+                    ...(typed.payload.summary !== undefined ? { failureSummary: typed.payload.summary } : {}),
                 };
             case "merge_steward_incident":
                 return {
                     ...facts,
-                    ...(typeof payload.incidentSummary === "string" ? { queueIncidentSummary: payload.incidentSummary } : {}),
+                    ...(typed.payload.incidentSummary !== undefined ? { queueIncidentSummary: typed.payload.incidentSummary } : {}),
                 };
-            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 "stop_requested":
+            case "operator_closed":
+            case "undelegated":
+            case "issue_removed":
+            case "pr_closed":
+            case "pr_merged":
+            case "run_released_authority":
                 return facts;
+            default:
+                return assertNever(typed, "Unhandled issue session event in run outcome facts");
         }
     }
     buildOutcomeSummary(params) {
@@ -318,7 +334,7 @@ export class RunFinalizer {
                     runType: params.run.runType,
                     summary: message,
                     preserveDirtyWorktree: true,
-                    dirtyWorktreeSummary: params.status.summary,
+                    ...(params.status.summary !== undefined ? { dirtyWorktreeSummary: params.status.summary } : {}),
                     dirtyWorktreeChangedPaths: params.status.changedPaths,
                     dirtyWorktreeMergeInProgress: params.status.mergeInProgress,
                 }),

package/dist/run-launcher.js

@@ -12,7 +12,7 @@ function sanitizePathSegment(value) {
     return value.replace(/[^a-zA-Z0-9._-]+/g, "-");
 }
 function shouldCompactThread(issue, threadGeneration, context) {
-    const followUpCount = typeof context?.followUpCount === "number" ? context.followUpCount : 0;
+    const followUpCount = context?.followUpCount ?? 0;
     return issue.threadId !== undefined
         && (threadGeneration ?? 0) >= 4
         && followUpCount >= 4;
@@ -125,10 +125,8 @@ export class RunLauncher {
                     ...(params.sourceHeadSha ? { sourceHeadSha: params.sourceHeadSha } : {}),
                     promptText: params.prompt,
                 });
-                const failureHeadSha = typeof params.effectiveContext?.failureHeadSha === "string"
-                    ? params.effectiveContext.failureHeadSha
-                    : typeof params.effectiveContext?.headSha === "string" ? params.effectiveContext.headSha : undefined;
-                const failureSignature = typeof params.effectiveContext?.failureSignature === "string" ? params.effectiveContext.failureSignature : undefined;
+                const failureHeadSha = params.effectiveContext?.failureHeadSha ?? params.effectiveContext?.headSha;
+                const failureSignature = params.effectiveContext?.failureSignature;
                 const claimUpdate = {
                     projectId: params.item.projectId,
                     linearIssueId: params.item.issueId,

package/dist/run-orchestrator.js

@@ -134,7 +134,7 @@ export class RunOrchestrator {
         this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, this.threadPorts.readThreadWithRetry, this.leasePorts.withHeldLease, this.leasePorts.heartbeatLease, this.leasePorts.releaseLease, feed, { interruptTurn: (options) => codex.interruptTurn(options) });
         this.runFailurePolicy = new RunFailurePolicy(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.wakeDispatcher, this.recoveryPorts.restoreIdleWorktree, this.runCompletionPolicy, (projectId) => this.config.projects.find((project) => project.id === projectId), feed);
         this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.runFailurePolicy, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, (projectId) => this.config.projects.find((project) => project.id === projectId)?.github?.repoFullName, feed, telemetry);
-        this.runWakePlanner = new RunWakePlanner(db);
+        this.runWakePlanner = new RunWakePlanner(db, logger);
         this.linearIssueProjection = new LinearIssueProjectionService(db, linearProvider, logger);
         this.runAdmission = new RunAdmissionController(db, this.linearIssueProjection);
         this.idleReconciler = new IdleIssueReconciler(db, config, this.wakeDispatcher, logger, feed, undefined, (issue) => this.linearSync.syncSession(issue), linearProvider);
@@ -419,11 +419,9 @@ export class RunOrchestrator {
         const effectiveContext = coordinationContext
             ? { ...coordinationContext, ...baseContextWithRecoveredActivity }
             : baseContextWithRecoveredActivity;
-        const sourceHeadSha = typeof effectiveContext?.failureHeadSha === "string"
-            ? effectiveContext.failureHeadSha
-            : typeof effectiveContext?.headSha === "string"
-                ? effectiveContext.headSha
-                : issue.prHeadSha;
+        const sourceHeadSha = effectiveContext?.failureHeadSha
+            ?? effectiveContext?.headSha
+            ?? issue.prHeadSha;
         const budgetExceeded = this.runWakePlanner.budgetExceeded(issue, project, runType, isRequestedChangesRunType);
         if (budgetExceeded) {
             this.emitRunSkipped(item, "budget_exceeded", issue, { runType });
@@ -508,11 +506,11 @@ export class RunOrchestrator {
         this.logger.info({ issueKey: issue.issueKey, runType, threadId, turnId }, `Started ${runType} run`);
         // Emit Linear activity + plan
         const freshIssue = this.db.issues.getIssue(item.projectId, item.issueId) ?? issue;
-        const reviewComments = Array.isArray(effectiveContext?.reviewComments) ? effectiveContext.reviewComments : undefined;
+        const reviewComments = effectiveContext?.reviewComments;
         const reviewRoundActivity = runType === "review_fix"
             ? buildReviewRoundStartedActivity({
                 round: Math.max(1, freshIssue.reviewFixAttempts),
-                ...(typeof effectiveContext?.reviewerName === "string" ? { reviewerName: effectiveContext.reviewerName } : {}),
+                ...(effectiveContext?.reviewerName !== undefined ? { reviewerName: effectiveContext.reviewerName } : {}),
                 ...(reviewComments ? { commentCount: reviewComments.length } : {}),
                 ...(typeof sourceHeadSha === "string" ? { headSha: sourceHeadSha } : {}),
             })