patchrelay 0.78.1 → 0.80.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/awaiting-input-reason.js

@@ -1,9 +1,8 @@
+import { deriveIssueExecutionState } from "./issue-execution-state.js";
 export function resolveAwaitingInputReason(params) {
-    if (params.issue.factoryState !== "awaiting_input") {
-        return undefined;
-    }
-    if (params.latestRun?.completionCheckOutcome === "needs_input") {
-        return "completion_check_question";
-    }
-    return "paused_local_work";
+    const state = deriveIssueExecutionState({
+        factoryState: params.issue.factoryState,
+        latestRunCompletionCheckOutcome: params.latestRun?.completionCheckOutcome,
+    });
+    return state.kind === "waiting_input" ? state.reason : undefined;
 }

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.80.0",
+  "commit": "61fe1041ab2b",
+  "builtAt": "2026-06-10T21:38:37.466Z"
 }

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-execution-state.js

@@ -0,0 +1,139 @@
+import { hasOpenPr } from "./pr-state.js";
+/** Run statuses that may legally occupy an issue's active-run slot. */
+const ACTIVE_RUN_STATUSES = new Set(["queued", "running"]);
+export function deriveIssueExecutionState(params) {
+    const factoryState = params.factoryState;
+    // Undelegation pauses automation for any non-finished issue and outranks
+    // every other answer (including an active run, which keeps executing but
+    // is reported as paused-with-downstream-continuation where relevant).
+    if (params.delegatedToPatchRelay === false
+        && factoryState !== "done"
+        && factoryState !== "failed"
+        && factoryState !== "escalated") {
+        const downstreamMayContinue = factoryState === "awaiting_queue"
+            || (hasOpenPr(params.prNumber, params.prState) && params.prReviewState === "approved");
+        return { kind: "undelegated", downstreamMayContinue };
+    }
+    // Active run facts win next — the issue is moving (or claims to be).
+    if (params.activeRunType || params.activeRunId !== undefined) {
+        const run = {
+            ...(params.activeRunId !== undefined ? { activeRunId: params.activeRunId } : {}),
+            ...(params.activeRunType ? { runType: params.activeRunType } : {}),
+            phase: resolveRunPhase(params),
+        };
+        // `done` + active run is a legitimate finalizing window (the post-run
+        // finalizer advances factoryState before clearing the slot), and
+        // `awaiting_input` + active run is a resumed reply turn. `failed` /
+        // `escalated` should never hold a slot: settleRun clears it before the
+        // terminal transition lands.
+        if (factoryState === "failed" || factoryState === "escalated") {
+            return {
+                kind: "inconsistent",
+                description: `terminal factoryState "${factoryState}" still holds an active run slot`,
+                run,
+            };
+        }
+        if (params.activeRunStatus !== undefined && !ACTIVE_RUN_STATUSES.has(params.activeRunStatus)) {
+            return {
+                kind: "inconsistent",
+                description: `active run slot points at a ${params.activeRunStatus} run`,
+                run,
+            };
+        }
+        return { kind: "running", run };
+    }
+    if (params.orchestrationSettleUntil) {
+        const settleAt = Date.parse(params.orchestrationSettleUntil);
+        if (Number.isFinite(settleAt) && settleAt > (params.now ?? Date.now())) {
+            return { kind: "settling", settleUntil: params.orchestrationSettleUntil };
+        }
+    }
+    const blockedByKeys = (params.blockedByKeys ?? []).filter((value) => value.trim().length > 0);
+    if (blockedByKeys.length > 0) {
+        return { kind: "blocked", blockedByKeys };
+    }
+    switch (factoryState) {
+        case "awaiting_input":
+            return {
+                kind: "waiting_input",
+                reason: params.latestRunCompletionCheckOutcome === "needs_input"
+                    ? "completion_check_question"
+                    : "paused_local_work",
+            };
+        case "changes_requested":
+            return { kind: "awaiting_followup", followup: "review_fix" };
+        case "repairing_ci":
+            return { kind: "awaiting_followup", followup: "ci_repair", checkName: params.latestFailureCheckName };
+        case "repairing_queue":
+            return { kind: "awaiting_followup", followup: "queue_repair" };
+        case "awaiting_queue":
+            return { kind: "idle_awaiting_external", waitingOn: "merge_queue" };
+        case "done":
+            return { kind: "terminal", outcome: "done" };
+        case "failed":
+            return { kind: "terminal", outcome: "failed" };
+        case "escalated":
+            return { kind: "terminal", outcome: "escalated" };
+        default:
+            break;
+    }
+    // delegated / implementing / pr_open / deploying: the wait, if any, is
+    // derived from live PR truth.
+    if (params.prCheckStatus === "failed" || params.prCheckStatus === "failure") {
+        return { kind: "idle_awaiting_external", waitingOn: "ci_failure", checkName: params.latestFailureCheckName };
+    }
+    if (params.prReviewState === "changes_requested") {
+        if (params.prCheckStatus === "passed" || params.prCheckStatus === "success") {
+            if (params.prHeadSha
+                && params.lastBlockingReviewHeadSha
+                && params.prHeadSha !== params.lastBlockingReviewHeadSha) {
+                return { kind: "idle_awaiting_external", waitingOn: "review_of_new_head" };
+            }
+            return { kind: "idle_awaiting_external", waitingOn: "blocking_review_same_head" };
+        }
+        return { kind: "idle_awaiting_external", waitingOn: "review_feedback" };
+    }
+    if (params.prReviewState === "approved") {
+        return { kind: "idle_awaiting_external", waitingOn: "downstream_automation" };
+    }
+    if (hasOpenPr(params.prNumber, params.prState)) {
+        return { kind: "idle_awaiting_external", waitingOn: "external_review" };
+    }
+    if (params.pendingRunType) {
+        return { kind: "ready", pendingRunType: params.pendingRunType };
+    }
+    return { kind: "idle" };
+}
+function resolveRunPhase(params) {
+    if (hasOpenPr(params.prNumber, params.prState) && (params.factoryState === "pr_open" || params.factoryState === "awaiting_queue")) {
+        return "finalizing_published_pr";
+    }
+    if (params.factoryState === "done") {
+        return "finalizing_merged_change";
+    }
+    return "working";
+}
+/** Build the deriver input from full records (issue row + resolved runs). */
+export function issueExecutionStateInputFromRecords(issue, extras) {
+    return {
+        delegatedToPatchRelay: issue.delegatedToPatchRelay,
+        factoryState: issue.factoryState,
+        activeRunId: issue.activeRunId,
+        activeRunType: extras?.activeRun?.runType,
+        activeRunStatus: extras?.activeRun?.status,
+        latestRunCompletionCheckOutcome: extras?.latestRun?.completionCheckOutcome,
+        pendingRunType: issue.pendingRunType,
+        blockedByKeys: extras?.blockedByKeys,
+        orchestrationSettleUntil: issue.orchestrationSettleUntil,
+        prNumber: issue.prNumber,
+        prState: issue.prState,
+        prHeadSha: issue.prHeadSha,
+        prReviewState: issue.prReviewState,
+        prCheckStatus: issue.prCheckStatus,
+        lastBlockingReviewHeadSha: issue.lastBlockingReviewHeadSha,
+        latestFailureCheckName: issue.lastGitHubFailureCheckName,
+    };
+}
+export function deriveIssueExecutionStateFromRecords(issue, extras) {
+    return deriveIssueExecutionState(issueExecutionStateInputFromRecords(issue, extras));
+}

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;
-    }
-}