patchrelay 0.82.0 → 0.83.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.82.0",
-  "commit": "91dee8b62165",
-  "builtAt": "2026-06-11T01:02:50.881Z"
+  "version": "0.83.0",
+  "commit": "5e17a07e67bc",
+  "builtAt": "2026-06-14T17:38:15.238Z"
 }

package/dist/db/migrations.js

@@ -237,6 +237,36 @@ CREATE TABLE IF NOT EXISTS issue_children (
   PRIMARY KEY (project_id, parent_linear_issue_id, child_linear_issue_id)
 );
 
+CREATE TABLE IF NOT EXISTS workflow_observations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id TEXT NOT NULL,
+  subject_id TEXT NOT NULL,
+  source TEXT NOT NULL,
+  type TEXT NOT NULL,
+  payload_json TEXT,
+  dedupe_key TEXT,
+  observed_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS workflow_tasks (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id TEXT NOT NULL,
+  subject_id TEXT NOT NULL,
+  task_id TEXT NOT NULL,
+  task_type TEXT NOT NULL,
+  run_type TEXT,
+  status TEXT NOT NULL,
+  reason TEXT NOT NULL,
+  requirements_json TEXT,
+  authority_epoch INTEGER NOT NULL DEFAULT 0,
+  gate_action TEXT NOT NULL,
+  gate_reason TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  closed_at TEXT,
+  UNIQUE(project_id, subject_id, task_id)
+);
+
 CREATE INDEX IF NOT EXISTS idx_issues_project ON issues(project_id, linear_issue_id);
 CREATE INDEX IF NOT EXISTS idx_issues_key ON issues(issue_key);
 CREATE INDEX IF NOT EXISTS idx_issues_ready ON issues(pending_run_type, active_run_id);
@@ -260,6 +290,13 @@ CREATE INDEX IF NOT EXISTS idx_issue_dependencies_issue ON issue_dependencies(pr
 CREATE INDEX IF NOT EXISTS idx_issue_dependencies_blocker ON issue_dependencies(project_id, blocker_linear_issue_id);
 CREATE INDEX IF NOT EXISTS idx_issue_children_parent ON issue_children(project_id, parent_linear_issue_id);
 CREATE INDEX IF NOT EXISTS idx_issue_children_child ON issue_children(project_id, child_linear_issue_id);
+CREATE INDEX IF NOT EXISTS idx_workflow_observations_subject ON workflow_observations(project_id, subject_id, id);
+CREATE INDEX IF NOT EXISTS idx_workflow_observations_recent ON workflow_observations(observed_at, id);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_workflow_observations_dedupe
+  ON workflow_observations(project_id, subject_id, source, dedupe_key)
+  WHERE dedupe_key IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_workflow_tasks_subject ON workflow_tasks(project_id, subject_id, status, id);
+CREATE INDEX IF NOT EXISTS idx_workflow_tasks_open ON workflow_tasks(status, project_id, updated_at);
 `;
 export function runPatchRelayMigrations(connection) {
     connection.exec(schema);
@@ -309,6 +346,12 @@ export function runPatchRelayMigrations(connection) {
     // Plan §4.4: hard publication-suppression flag for the
     // mid-run-approval cancellation primitive.
     addColumnIfMissing(connection, "runs", "should_not_publish", "INTEGER NOT NULL DEFAULT 0");
+    addColumnIfMissing(connection, "runs", "authority_epoch", "INTEGER NOT NULL DEFAULT 0");
+    addColumnIfMissing(connection, "runs", "lease_revoked_at", "TEXT");
+    addColumnIfMissing(connection, "runs", "lease_revoke_reason", "TEXT");
+    addColumnIfMissing(connection, "workflow_tasks", "authority_epoch", "INTEGER NOT NULL DEFAULT 0");
+    addColumnIfMissing(connection, "workflow_tasks", "gate_action", "TEXT NOT NULL DEFAULT 'wait'");
+    addColumnIfMissing(connection, "workflow_tasks", "gate_reason", "TEXT");
     addColumnIfMissing(connection, "issues", "last_blocking_review_head_sha", "TEXT");
     // Collapse awaiting_review into pr_open (state normalization)
     connection.prepare("UPDATE issues SET factory_state = 'pr_open' WHERE factory_state = 'awaiting_review'").run();

package/dist/db/run-store.js

@@ -7,22 +7,50 @@ export class RunStore {
     issues;
     issueSessionProjection;
     telemetry;
-    constructor(connection, mapRunRow, issues, issueSessionProjection, telemetry = noopTelemetry) {
+    workflowObservations;
+    constructor(connection, mapRunRow, issues, issueSessionProjection, telemetry = noopTelemetry, workflowObservations) {
         this.connection = connection;
         this.mapRunRow = mapRunRow;
         this.issues = issues;
         this.issueSessionProjection = issueSessionProjection;
         this.telemetry = telemetry;
+        this.workflowObservations = workflowObservations;
     }
     projectIssueRun(issue, options) {
         this.issueSessionProjection.issueRunChanged(issue, options);
     }
+    appendRunnerObservation(type, run, payload = {}) {
+        this.workflowObservations?.appendObservation({
+            projectId: run.projectId,
+            subjectId: run.linearIssueId,
+            source: "runner",
+            type,
+            payloadJson: JSON.stringify({
+                runId: run.id,
+                runType: run.runType,
+                status: run.status,
+                authorityEpoch: run.authorityEpoch,
+                ...(run.launchPhase ? { launchPhase: run.launchPhase } : {}),
+                ...(run.sourceHeadSha ? { sourceHeadSha: run.sourceHeadSha } : {}),
+                ...(run.threadId ? { threadId: run.threadId } : {}),
+                ...(run.turnId ? { turnId: run.turnId } : {}),
+                ...(run.parentThreadId ? { parentThreadId: run.parentThreadId } : {}),
+                ...(run.failureReason ? { failureReason: run.failureReason } : {}),
+                ...(run.shouldNotPublish ? { shouldNotPublish: true } : {}),
+                ...(run.leaseRevokedAt ? { leaseRevokedAt: run.leaseRevokedAt } : {}),
+                ...(run.leaseRevokeReason ? { leaseRevokeReason: run.leaseRevokeReason } : {}),
+                ...(run.endedAt ? { endedAt: run.endedAt } : {}),
+                ...payload,
+            }),
+            dedupeKey: `runner:${type}:${run.id}`,
+        });
+    }
     createRun(params) {
         const now = isoNow();
         const result = this.connection.prepare(`
-      INSERT INTO runs (issue_id, project_id, linear_issue_id, run_type, status, launch_phase, source_head_sha, prompt_text, started_at)
-      VALUES (?, ?, ?, ?, 'queued', 'claimed', ?, ?, ?)
-    `).run(params.issueId, params.projectId, params.linearIssueId, params.runType, params.sourceHeadSha ?? null, params.promptText ?? null, now);
+      INSERT INTO runs (issue_id, project_id, linear_issue_id, run_type, status, launch_phase, source_head_sha, prompt_text, authority_epoch, started_at)
+      VALUES (?, ?, ?, ?, 'queued', 'claimed', ?, ?, ?, ?)
+    `).run(params.issueId, params.projectId, params.linearIssueId, params.runType, params.sourceHeadSha ?? null, params.promptText ?? null, params.authorityEpoch ?? 0, now);
         const run = this.getRunById(Number(result.lastInsertRowid));
         const issue = this.issues.getIssue(params.projectId, params.linearIssueId);
         if (issue) {
@@ -36,6 +64,7 @@ export class RunStore {
             runType: run.runType,
             ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
         });
+        this.appendRunnerObservation("runner.run_claimed", run);
         return run;
     }
     getRunById(id) {
@@ -97,6 +126,7 @@ export class RunStore {
             runType: run.runType,
             ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
         });
+        this.appendRunnerObservation("runner.run_started", run);
     }
     updateRunTurnId(runId, turnId) {
         this.connection.prepare("UPDATE runs SET turn_id = ? WHERE id = ?").run(turnId, runId);
@@ -147,6 +177,7 @@ export class RunStore {
             runType: run.runType,
             ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
         });
+        this.appendRunnerObservation("runner.run_finished", run);
     }
     // Plan §4.4: flag a still-running run as superseded. We deliberately
     // do NOT change `status` here — the Codex turn must finish naturally
@@ -175,6 +206,33 @@ export class RunStore {
                 lastRunType: run.runType,
             });
         }
+        this.appendRunnerObservation("runner.run_superseded_requested", run, {
+            reason: params.reason,
+        });
+    }
+    revokeRunLease(runId, params) {
+        this.connection.prepare(`
+      UPDATE runs SET
+        should_not_publish = 1,
+        lease_revoked_at = COALESCE(lease_revoked_at, ?),
+        lease_revoke_reason = COALESCE(lease_revoke_reason, ?),
+        failure_reason = COALESCE(failure_reason, ?)
+      WHERE id = ?
+        AND status IN ('queued', 'running')
+    `).run(params.revokedAt ?? isoNow(), params.reason, params.reason, runId);
+        const run = this.getRunById(runId);
+        if (!run)
+            return;
+        const issue = this.issues.getIssue(run.projectId, run.linearIssueId);
+        if (issue) {
+            this.projectIssueRun(issue, {
+                summaryText: params.reason,
+                lastRunType: run.runType,
+            });
+        }
+        this.appendRunnerObservation("runner.run_revoked", run, {
+            reason: params.reason,
+        });
     }
     saveCompletionCheck(runId, params) {
         this.connection.prepare(`

package/dist/db/schema-guard.js

@@ -3,6 +3,8 @@ const REQUIRED_PATCHRELAY_TABLES = [
     "runs",
     "issue_sessions",
     "issue_session_events",
+    "workflow_observations",
+    "workflow_tasks",
 ];
 export function assertPatchRelaySchemaReady(connection, databasePath) {
     const rows = connection

package/dist/db/workflow-observation-store.js

@@ -0,0 +1,61 @@
+import { isoNow } from "./shared.js";
+export class WorkflowObservationStore {
+    connection;
+    mapWorkflowObservationRow;
+    constructor(connection, mapWorkflowObservationRow) {
+        this.connection = connection;
+        this.mapWorkflowObservationRow = mapWorkflowObservationRow;
+    }
+    appendObservation(params) {
+        if (params.dedupeKey) {
+            const existing = this.connection.prepare(`
+        SELECT * FROM workflow_observations
+        WHERE project_id = ? AND subject_id = ? AND source = ? AND dedupe_key = ?
+        ORDER BY id DESC LIMIT 1
+      `).get(params.projectId, params.subjectId, params.source, params.dedupeKey);
+            if (existing) {
+                return this.mapWorkflowObservationRow(existing);
+            }
+        }
+        const result = this.connection.prepare(`
+      INSERT INTO workflow_observations (
+        project_id, subject_id, source, type, payload_json, dedupe_key, observed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(params.projectId, params.subjectId, params.source, params.type, params.payloadJson ?? null, params.dedupeKey ?? null, params.observedAt ?? isoNow());
+        return this.getObservation(Number(result.lastInsertRowid));
+    }
+    getObservation(id) {
+        const row = this.connection.prepare("SELECT * FROM workflow_observations WHERE id = ?")
+            .get(id);
+        return row ? this.mapWorkflowObservationRow(row) : undefined;
+    }
+    listObservations(projectId, subjectId) {
+        const rows = this.connection.prepare(`
+      SELECT * FROM workflow_observations
+      WHERE project_id = ? AND subject_id = ?
+      ORDER BY id
+    `).all(projectId, subjectId);
+        return rows.map(this.mapWorkflowObservationRow);
+    }
+    listRecentObservations(params = {}) {
+        const conditions = [];
+        const values = [];
+        if (params.projectId) {
+            conditions.push("project_id = ?");
+            values.push(params.projectId);
+        }
+        if (params.observedAfter) {
+            conditions.push("observed_at >= ?");
+            values.push(params.observedAfter);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+        const limit = params.limit ?? 250;
+        const rows = this.connection.prepare(`
+      SELECT * FROM workflow_observations
+      ${where}
+      ORDER BY id DESC
+      LIMIT ?
+    `).all(...values, limit);
+        return rows.map(this.mapWorkflowObservationRow);
+    }
+}

package/dist/db/workflow-task-store.js

@@ -0,0 +1,111 @@
+import { isoNow } from "./shared.js";
+export class WorkflowTaskStore {
+    connection;
+    mapWorkflowTaskRow;
+    constructor(connection, mapWorkflowTaskRow) {
+        this.connection = connection;
+        this.mapWorkflowTaskRow = mapWorkflowTaskRow;
+    }
+    reconcileTasks(params) {
+        const reconciledAt = params.reconciledAt ?? isoNow();
+        return this.connection.transaction(() => {
+            const previousOpen = this.listOpenTasks(params.projectId, params.subjectId);
+            const currentTaskIds = new Set(params.tasks.map((entry) => entry.task.id));
+            const opened = [];
+            const updated = [];
+            for (const entry of params.tasks) {
+                const existing = this.getTask(params.projectId, params.subjectId, entry.task.id);
+                const requirementsJson = entry.task.requirements ? JSON.stringify(entry.task.requirements) : undefined;
+                this.connection.prepare(`
+          INSERT INTO workflow_tasks (
+            project_id, subject_id, task_id, task_type, run_type, status, reason,
+            requirements_json, authority_epoch, gate_action, gate_reason,
+            created_at, updated_at, closed_at
+          ) VALUES (?, ?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, ?, NULL)
+          ON CONFLICT(project_id, subject_id, task_id) DO UPDATE SET
+            task_type = excluded.task_type,
+            run_type = excluded.run_type,
+            status = 'open',
+            reason = excluded.reason,
+            requirements_json = excluded.requirements_json,
+            authority_epoch = excluded.authority_epoch,
+            gate_action = excluded.gate_action,
+            gate_reason = excluded.gate_reason,
+            updated_at = excluded.updated_at,
+            closed_at = NULL
+        `).run(params.projectId, params.subjectId, entry.task.id, entry.task.type, entry.task.runType ?? null, entry.task.reason, requirementsJson ?? null, entry.authorityEpoch, entry.gateAction, entry.gateReason ?? null, existing?.createdAt ?? reconciledAt, reconciledAt);
+                const saved = this.getTask(params.projectId, params.subjectId, entry.task.id);
+                if (!existing || existing.status === "closed") {
+                    opened.push(saved);
+                }
+                else {
+                    updated.push(saved);
+                }
+            }
+            const closed = [];
+            for (const stale of previousOpen) {
+                if (currentTaskIds.has(stale.taskId))
+                    continue;
+                this.connection.prepare(`
+          UPDATE workflow_tasks
+          SET status = 'closed',
+              updated_at = ?,
+              closed_at = ?
+          WHERE id = ?
+            AND status = 'open'
+        `).run(reconciledAt, reconciledAt, stale.id);
+                const closedTask = this.getTaskById(stale.id);
+                if (closedTask) {
+                    closed.push(closedTask);
+                }
+            }
+            return {
+                opened,
+                updated,
+                closed,
+                open: this.listOpenTasks(params.projectId, params.subjectId),
+            };
+        })();
+    }
+    getTask(projectId, subjectId, taskId) {
+        const row = this.connection.prepare(`
+      SELECT * FROM workflow_tasks
+      WHERE project_id = ? AND subject_id = ? AND task_id = ?
+    `).get(projectId, subjectId, taskId);
+        return row ? this.mapWorkflowTaskRow(row) : undefined;
+    }
+    getTaskById(id) {
+        const row = this.connection.prepare("SELECT * FROM workflow_tasks WHERE id = ?").get(id);
+        return row ? this.mapWorkflowTaskRow(row) : undefined;
+    }
+    listTasks(projectId, subjectId) {
+        const rows = this.connection.prepare(`
+      SELECT * FROM workflow_tasks
+      WHERE project_id = ? AND subject_id = ?
+      ORDER BY id
+    `).all(projectId, subjectId);
+        return rows.map(this.mapWorkflowTaskRow);
+    }
+    listOpenTasks(projectId, subjectId) {
+        const rows = this.connection.prepare(`
+      SELECT * FROM workflow_tasks
+      WHERE project_id = ? AND subject_id = ? AND status = 'open'
+      ORDER BY id
+    `).all(projectId, subjectId);
+        return rows.map(this.mapWorkflowTaskRow);
+    }
+    listOpenRunnableTasks(projectId) {
+        const rows = projectId
+            ? this.connection.prepare(`
+          SELECT * FROM workflow_tasks
+          WHERE status = 'open' AND task_type = 'run' AND gate_action = 'start' AND project_id = ?
+          ORDER BY updated_at, id
+        `).all(projectId)
+            : this.connection.prepare(`
+          SELECT * FROM workflow_tasks
+          WHERE status = 'open' AND task_type = 'run' AND gate_action = 'start'
+          ORDER BY updated_at, id
+        `).all();
+        return rows.map(this.mapWorkflowTaskRow);
+    }
+}

package/dist/db.js

@@ -6,6 +6,8 @@ import { OperatorFeedStore } from "./db/operator-feed-store.js";
 import { RepositoryLinkStore } from "./db/repository-link-store.js";
 import { RunStore } from "./db/run-store.js";
 import { WebhookEventStore } from "./db/webhook-event-store.js";
+import { WorkflowObservationStore } from "./db/workflow-observation-store.js";
+import { WorkflowTaskStore } from "./db/workflow-task-store.js";
 import { runPatchRelayMigrations } from "./db/migrations.js";
 import { assertPatchRelaySchemaReady } from "./db/schema-guard.js";
 import { SqliteConnection } from "./db/shared.js";
@@ -14,6 +16,7 @@ import { syncIssueSessionFromIssue } from "./issue-session-projector.js";
 import { noopTelemetry } from "./telemetry.js";
 import { TrackedIssueQuery } from "./tracked-issue-query.js";
 import { WorkflowWakeResolver } from "./workflow-wake-resolver.js";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.js";
 export class PatchRelayDatabase {
     connection;
     issueSessionProjection;
@@ -25,6 +28,8 @@ export class PatchRelayDatabase {
     operatorFeed;
     repositories;
     webhookEvents;
+    workflowObservations;
+    workflowTasks;
     issues;
     issueSessions;
     workflowWakes;
@@ -45,6 +50,8 @@ export class PatchRelayDatabase {
         this.operatorFeed = new OperatorFeedStore(this.connection);
         this.repositories = new RepositoryLinkStore(this.connection);
         this.webhookEvents = new WebhookEventStore(this.connection);
+        this.workflowObservations = new WorkflowObservationStore(this.connection, mapWorkflowObservationRow);
+        this.workflowTasks = new WorkflowTaskStore(this.connection, mapWorkflowTaskRow);
         this.issueSessionProjection = new ImmediateIssueSessionProjectionInvalidator({
             getIssue: (projectId, linearIssueId) => this.issues.getIssue(projectId, linearIssueId),
             listDependents: (projectId, blockerLinearIssueId) => this.issues.listDependents(projectId, blockerLinearIssueId),
@@ -61,10 +68,13 @@ export class PatchRelayDatabase {
             telemetry: this.telemetryProxy,
         });
         this.issues = new IssueStore(this.connection, this.issueSessionProjection);
-        this.runs = new RunStore(this.connection, mapRunRow, this.issues, this.issueSessionProjection, this.telemetryProxy);
+        this.runs = new RunStore(this.connection, mapRunRow, this.issues, this.issueSessionProjection, this.telemetryProxy, this.workflowObservations);
         this.issueSessions = new IssueSessionStore(this.connection, mapIssueSessionRow, mapIssueSessionEventRow, this.issues, this.runs, this.issueSessionProjection, this.telemetryProxy);
         this.workflowWakes = new WorkflowWakeResolver(this.issues, this.issueSessions);
-        this.trackedIssues = new TrackedIssueQuery(this.issues, this.issueSessions, this.workflowWakes, this.runs);
+        this.trackedIssues = new TrackedIssueQuery(this.issues, this.issueSessions, {
+            hasPendingWake: (projectId, linearIssueId) => this.workflowWakes.hasPendingWake(projectId, linearIssueId)
+                || this.workflowTasks.listOpenRunnableTasks(projectId).some((task) => task.subjectId === linearIssueId),
+        }, this.runs);
     }
     databasePath;
     setTelemetry(telemetry) {
@@ -148,7 +158,20 @@ export class PatchRelayDatabase {
         return this.issues.countUnresolvedBlockers(projectId, linearIssueId);
     }
     listIssuesReadyForExecution() {
-        return this.trackedIssues.listIssuesReadyForExecution();
+        const ready = new Map();
+        for (const issue of this.issues.listIssues()) {
+            reconcileWorkflowTasksForIssue(this, issue);
+        }
+        for (const issue of this.trackedIssues.listIssuesReadyForExecution()) {
+            ready.set(`${issue.projectId}:${issue.linearIssueId}`, issue);
+        }
+        for (const task of this.workflowTasks.listOpenRunnableTasks()) {
+            ready.set(`${task.projectId}:${task.subjectId}`, {
+                projectId: task.projectId,
+                linearIssueId: task.subjectId,
+            });
+        }
+        return [...ready.values()];
     }
     /**
      * Issues idle in pr_open with no active run — candidates for state
@@ -274,7 +297,41 @@ function mapRunRow(row) {
         ...(row.report_json !== null ? { reportJson: String(row.report_json) } : {}),
         ...(row.failure_reason !== null ? { failureReason: String(row.failure_reason) } : {}),
         ...(row.should_not_publish === 1 || row.should_not_publish === true ? { shouldNotPublish: true } : {}),
+        authorityEpoch: Number(row.authority_epoch ?? 0),
+        ...(row.lease_revoked_at !== null ? { leaseRevokedAt: String(row.lease_revoked_at) } : {}),
+        ...(row.lease_revoke_reason !== null ? { leaseRevokeReason: String(row.lease_revoke_reason) } : {}),
         startedAt: String(row.started_at),
         ...(row.ended_at !== null ? { endedAt: String(row.ended_at) } : {}),
     };
 }
+function mapWorkflowObservationRow(row) {
+    return {
+        id: Number(row.id),
+        projectId: String(row.project_id),
+        subjectId: String(row.subject_id),
+        source: String(row.source),
+        type: String(row.type),
+        ...(row.payload_json !== null && row.payload_json !== undefined ? { payloadJson: String(row.payload_json) } : {}),
+        ...(row.dedupe_key !== null && row.dedupe_key !== undefined ? { dedupeKey: String(row.dedupe_key) } : {}),
+        observedAt: String(row.observed_at),
+    };
+}
+function mapWorkflowTaskRow(row) {
+    return {
+        id: Number(row.id),
+        projectId: String(row.project_id),
+        subjectId: String(row.subject_id),
+        taskId: String(row.task_id),
+        taskType: String(row.task_type),
+        ...(row.run_type !== null && row.run_type !== undefined ? { runType: String(row.run_type) } : {}),
+        status: String(row.status),
+        reason: String(row.reason),
+        ...(row.requirements_json !== null && row.requirements_json !== undefined ? { requirementsJson: String(row.requirements_json) } : {}),
+        authorityEpoch: Number(row.authority_epoch ?? 0),
+        gateAction: String(row.gate_action),
+        ...(row.gate_reason !== null && row.gate_reason !== undefined ? { gateReason: String(row.gate_reason) } : {}),
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+        ...(row.closed_at !== null && row.closed_at !== undefined ? { closedAt: String(row.closed_at) } : {}),
+    };
+}

package/dist/github-review-context.js

@@ -0,0 +1,90 @@
+import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
+export async function resolveGitHubRequestedChangesContext(params) {
+    const { linearIssueId, event, fetchImpl } = params;
+    const reviewComments = params.includeInlineComments === false
+        ? undefined
+        : await fetchReviewCommentsForEvent(event, fetchImpl);
+    const identity = buildRequestedChangesWakeIdentity({
+        linearIssueId,
+        headSha: event.headSha,
+        reviewCommitId: event.reviewCommitId,
+        reviewId: event.reviewId,
+        reviewerName: event.reviewerName,
+    });
+    return {
+        dedupeKey: identity.dedupeKey,
+        context: {
+            requestedChangesCoalesceKey: identity.coalesceKey,
+            ...(identity.headSha ? { requestedChangesHeadSha: identity.headSha } : {}),
+            reviewBody: event.reviewBody,
+            reviewCommitId: event.reviewCommitId,
+            reviewId: event.reviewId,
+            reviewUrl: buildGitHubReviewUrl(event.repoFullName, event.prNumber, event.reviewId),
+            reviewerName: event.reviewerName,
+            ...(reviewComments && reviewComments.length > 0 ? { reviewComments } : {}),
+        },
+    };
+}
+async function fetchReviewCommentsForEvent(event, fetchImpl) {
+    if (event.triggerEvent !== "review_changes_requested") {
+        return undefined;
+    }
+    if (!event.repoFullName || event.prNumber === undefined || event.reviewId === undefined) {
+        return undefined;
+    }
+    const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+    if (!token) {
+        return undefined;
+    }
+    const [owner, repo] = event.repoFullName.split("/", 2);
+    if (!owner || !repo) {
+        return undefined;
+    }
+    const response = await fetchImpl(`https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${event.prNumber}/reviews/${event.reviewId}/comments?per_page=100`, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/vnd.github+json",
+            "User-Agent": "patchrelay",
+            "X-GitHub-Api-Version": "2022-11-28",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub review comment fetch failed (${response.status})`);
+    }
+    const payload = await response.json();
+    if (!Array.isArray(payload)) {
+        return undefined;
+    }
+    const comments = [];
+    for (const entry of payload) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const record = entry;
+        const body = typeof record.body === "string" ? record.body.trim() : "";
+        const id = typeof record.id === "number" ? record.id : undefined;
+        if (!body || id === undefined)
+            continue;
+        comments.push({
+            id,
+            body,
+            ...(typeof record.path === "string" ? { path: record.path } : {}),
+            ...(typeof record.line === "number" ? { line: record.line } : {}),
+            ...(typeof record.side === "string" ? { side: record.side } : {}),
+            ...(typeof record.start_line === "number" ? { startLine: record.start_line } : {}),
+            ...(typeof record.start_side === "string" ? { startSide: record.start_side } : {}),
+            ...(typeof record.commit_id === "string" ? { commitId: record.commit_id } : {}),
+            ...(typeof record.html_url === "string" ? { url: record.html_url } : {}),
+            ...(typeof record.diff_hunk === "string" ? { diffHunk: record.diff_hunk } : {}),
+            ...(typeof record.user?.login === "string"
+                ? { authorLogin: String(record.user.login) }
+                : {}),
+        });
+    }
+    return comments;
+}
+function buildGitHubReviewUrl(repoFullName, prNumber, reviewId) {
+    if (!repoFullName || prNumber === undefined || reviewId === undefined) {
+        return undefined;
+    }
+    return `https://github.com/${repoFullName}/pull/${prNumber}#pullrequestreview-${reviewId}`;
+}

package/dist/github-webhook-handler.js

@@ -6,11 +6,12 @@ import { createGitHubCiSnapshotResolver, createGitHubFailureContextResolver, } f
 import { resolveGitHubWebhookIssue } from "./github-webhook-issue-resolution.js";
 import { maybeCloseLatePublishedImplementationPr } from "./github-webhook-late-publication-guard.js";
 import { projectGitHubWebhookState } from "./github-webhook-state-projector.js";
-import { maybeEnqueueGitHubReactiveRun } from "./github-webhook-reactive-run.js";
+import { resolveGitHubRequestedChangesContext } from "./github-review-context.js";
 import { maybeRunSequenceBackstop } from "./github-webhook-sequence-backstop.js";
 import { maybeFanChildRebaseWakes } from "./github-webhook-stack-coordination.js";
 import { handleGitHubTerminalPrEvent } from "./github-webhook-terminal-handler.js";
 import { WakeDispatcher } from "./wake-dispatcher.js";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.js";
 export class GitHubWebhookHandler {
     config;
     db;
@@ -126,16 +127,68 @@ export class GitHubWebhookHandler {
             failureContextResolver: this.failureContextResolver,
             ciSnapshotResolver: this.ciSnapshotResolver,
         }, issue, event, project, resolved.linkedBy);
-        await maybeEnqueueGitHubReactiveRun({
-            db: this.db,
-            logger: this.logger,
-            feed: this.feed,
-            wakeDispatcher: this.wakeDispatcher,
-            issue: freshIssue,
-            event,
-            project,
-            failureContextResolver: this.failureContextResolver,
-            fetchImpl: this.fetchImpl,
+        const requestedChangesContext = event.triggerEvent === "review_changes_requested"
+            ? await resolveGitHubRequestedChangesContext({
+                linearIssueId: freshIssue.linearIssueId,
+                event,
+                fetchImpl: this.fetchImpl,
+            }).catch((error) => {
+                this.logger.warn({
+                    issueKey: freshIssue.issueKey,
+                    prNumber: event.prNumber,
+                    reviewId: event.reviewId,
+                    error: error instanceof Error ? error.message : String(error),
+                }, "Failed to fetch inline review comments for requested-changes observation");
+                return resolveGitHubRequestedChangesContext({
+                    linearIssueId: freshIssue.linearIssueId,
+                    event,
+                    fetchImpl: this.fetchImpl,
+                    includeInlineComments: false,
+                });
+            })
+            : undefined;
+        this.db.workflowObservations.appendObservation({
+            projectId: freshIssue.projectId,
+            subjectId: freshIssue.linearIssueId,
+            source: "github",
+            type: `github.${event.triggerEvent}`,
+            payloadJson: JSON.stringify({
+                triggerEvent: event.triggerEvent,
+                repoFullName: event.repoFullName,
+                branchName: event.branchName,
+                headSha: event.headSha,
+                prNumber: event.prNumber,
+                prState: event.prState,
+                reviewState: event.reviewState,
+                reviewId: event.reviewId,
+                reviewCommitId: event.reviewCommitId,
+                reviewerName: event.reviewerName,
+                requestedChangesContext: requestedChangesContext?.context,
+                checkStatus: event.checkStatus,
+                checkName: event.checkName,
+                checkUrl: event.checkUrl,
+            }),
+            dedupeKey: requestedChangesContext?.dedupeKey ?? [
+                event.triggerEvent,
+                event.repoFullName,
+                event.prNumber ?? event.branchName,
+                event.headSha,
+                event.reviewId ?? event.checkName ?? "",
+                event.reviewState ?? event.checkStatus ?? event.prState ?? "",
+            ].join(":"),
+        });
+        const workflowReconciliation = reconcileWorkflowTasksForIssue(this.db, freshIssue);
+        const changedRunnableWorkflowTask = [
+            ...workflowReconciliation.result.opened,
+            ...workflowReconciliation.result.updated,
+        ].some((task) => task.gateAction === "start" && task.runType);
+        const shouldDispatchWorkflowTask = event.triggerEvent === "review_changes_requested"
+            || event.triggerEvent === "check_failed"
+            || event.triggerEvent === "pr_closed";
+        await this.wakeDispatcher.withTick(async () => {
+            if (shouldDispatchWorkflowTask && changedRunnableWorkflowTask) {
+                this.wakeDispatcher.dispatchIfWakePending(freshIssue.projectId, freshIssue.linearIssueId);
+            }
         });
         if (event.triggerEvent === "pr_opened") {
             await maybeRunSequenceBackstop({