patchrelay 0.29.3 → 0.30.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.29.3",
-  "commit": "7f7c95a676dc",
-  "builtAt": "2026-04-01T00:22:06.894Z"
+  "version": "0.30.1",
+  "commit": "dee1d8b522b1",
+  "builtAt": "2026-04-01T08:31:08.208Z"
 }

package/dist/cli/watch/App.js

@@ -35,7 +35,11 @@ async function postStop(baseUrl, issueKey, bearerToken) {
             headers,
             signal: AbortSignal.timeout(5000),
         });
-        return await response.json();
+        const result = await response.json();
+        if (result.ok === undefined && result.stopped === true) {
+            return { ...result, ok: true };
+        }
+        return result;
     }
     catch {
         return { reason: "request failed" };

package/dist/cli/watch/IssueDetailView.js

@@ -44,5 +44,5 @@ export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, a
     const history = useMemo(() => buildStateHistory(rawRuns, rawFeedEvents, issue.factoryState, activeRunId), [rawRuns, rawFeedEvents, issue.factoryState, activeRunId]);
     const graph = useMemo(() => buildPatchRelayStateGraph(history, issue.factoryState), [history, issue.factoryState]);
     const queueObservations = useMemo(() => buildPatchRelayQueueObservations(issue, rawFeedEvents), [issue, rawFeedEvents]);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: key }), _jsx(Text, { color: "cyan", children: issue.factoryState }), issue.activeRunType && _jsx(Text, { color: "yellow", children: issue.activeRunType }), issue.prNumber !== undefined && _jsxs(Text, { dimColor: true, children: ["#", issue.prNumber] }), activeRunStartedAt && _jsx(ElapsedTime, { startedAt: activeRunStartedAt }), meta.length > 0 && _jsx(Text, { dimColor: true, children: meta.join("  ") }), detailTab === "timeline" && _jsx(Text, { dimColor: true, children: timelineMode }), follow && _jsx(Text, { color: "yellow", children: "follow" }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }), issue.title && _jsx(Text, { children: issue.title }), detailTab === "timeline" ? (_jsxs(_Fragment, { children: [plan && plan.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "Plan" }), _jsx(Text, { children: progressBar(plan.filter((s) => s.status === "completed").length, plan.length, 16) }), _jsxs(Text, { dimColor: true, children: [plan.filter((s) => s.status === "completed").length, "/", plan.length] })] }), plan.map((entry, i) => (_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: planStepColor(entry.status), children: ["[", planStepSymbol(entry.status), "]"] }), _jsx(Text, { children: entry.step })] }, `plan-${i}`)))] })), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Timeline, { entries: timeline, follow: follow, mode: timelineMode }) })] })) : (_jsxs(_Fragment, { children: [_jsx(FactoryStateGraph, { main: graph.main, prLoops: graph.prLoops, queueLoop: graph.queueLoop, exits: graph.exits }), _jsx(QueueObservationView, { observations: queueObservations }), _jsx(Box, { marginTop: 1, children: _jsx(StateHistoryView, { history: history, plan: plan, activeRunId: activeRunId }) })] })), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab, timelineMode: timelineMode }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: key }), _jsx(Text, { color: "cyan", children: issue.factoryState }), issue.blockedByCount > 0 && _jsxs(Text, { color: "yellow", children: ["blocked by ", issue.blockedByKeys.join(", ")] }), issue.readyForExecution && !issue.activeRunType && issue.blockedByCount === 0 && _jsx(Text, { color: "blueBright", children: "ready" }), issue.activeRunType && _jsx(Text, { color: "yellow", children: issue.activeRunType }), issue.prNumber !== undefined && _jsxs(Text, { dimColor: true, children: ["#", issue.prNumber] }), activeRunStartedAt && _jsx(ElapsedTime, { startedAt: activeRunStartedAt }), meta.length > 0 && _jsx(Text, { dimColor: true, children: meta.join("  ") }), detailTab === "timeline" && _jsx(Text, { dimColor: true, children: timelineMode }), follow && _jsx(Text, { color: "yellow", children: "follow" }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }), issue.title && _jsx(Text, { children: issue.title }), detailTab === "timeline" ? (_jsxs(_Fragment, { children: [plan && plan.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "Plan" }), _jsx(Text, { children: progressBar(plan.filter((s) => s.status === "completed").length, plan.length, 16) }), _jsxs(Text, { dimColor: true, children: [plan.filter((s) => s.status === "completed").length, "/", plan.length] })] }), plan.map((entry, i) => (_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: planStepColor(entry.status), children: ["[", planStepSymbol(entry.status), "]"] }), _jsx(Text, { children: entry.step })] }, `plan-${i}`)))] })), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Timeline, { entries: timeline, follow: follow, mode: timelineMode }) })] })) : (_jsxs(_Fragment, { children: [_jsx(FactoryStateGraph, { main: graph.main, prLoops: graph.prLoops, queueLoop: graph.queueLoop, exits: graph.exits }), _jsx(QueueObservationView, { observations: queueObservations }), _jsx(Box, { marginTop: 1, children: _jsx(StateHistoryView, { history: history, plan: plan, activeRunId: activeRunId }) })] })), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab, timelineMode: timelineMode }) })] }));
 }

package/dist/cli/watch/IssueRow.js

@@ -2,6 +2,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { summarizeIssueStatusNote } from "./issue-status-note.js";
 const STATE_COLORS = {
+    blocked: "yellow",
+    ready: "blueBright",
     delegated: "cyan",
     implementing: "cyan",
     pr_open: "cyan",
@@ -15,6 +17,8 @@ const STATE_COLORS = {
     awaiting_input: "yellow",
 };
 const STATE_SHORT = {
+    blocked: "blocked",
+    ready: "ready",
     delegated: "delegated",
     implementing: "impl",
     pr_open: "pr open",
@@ -69,7 +73,12 @@ function truncate(text, max) {
 }
 const TERMINAL_STATES = new Set(["done", "failed", "escalated", "awaiting_input"]);
 function formatStatus(issue) {
-    const state = STATE_SHORT[issue.factoryState] ?? issue.factoryState;
+    const effectiveState = issue.blockedByCount > 0 && !issue.activeRunType
+        ? "blocked"
+        : issue.readyForExecution && !issue.activeRunType
+            ? "ready"
+            : issue.factoryState;
+    const state = STATE_SHORT[effectiveState] ?? effectiveState;
     // Terminal states: just the label, no run symbol
     if (TERMINAL_STATES.has(issue.factoryState))
         return state;
@@ -88,5 +97,5 @@ export function IssueRow({ issue, selected, titleWidth }) {
     const tw = titleWidth ?? 30;
     const title = issue.title ? truncate(issue.title, tw) : "";
     const detail = selected ? summarizeIssueStatusNote(issue.statusNote) : undefined;
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: detail ? 1 : 0, children: [_jsxs(Box, { children: [_jsx(Text, { color: selected ? "blueBright" : "white", bold: selected, children: selected ? "\u25b8" : " " }), _jsx(Text, { bold: true, children: ` ${key.padEnd(9)}` }), _jsx(Text, { color: stateColor(issue.factoryState), children: ` ${status.padEnd(12)}` }), _jsx(Text, { dimColor: true, children: ` ${pr.padEnd(6)}` }), _jsx(Text, { dimColor: true, children: ` ${ago.padStart(3)}` }), title ? _jsx(Text, { dimColor: true, children: ` ${title}` }) : null] }), detail ? (_jsx(Box, { paddingLeft: 4, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: detail }) })) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: detail ? 1 : 0, children: [_jsxs(Box, { children: [_jsx(Text, { color: selected ? "blueBright" : "white", bold: selected, children: selected ? "\u25b8" : " " }), _jsx(Text, { bold: true, children: ` ${key.padEnd(9)}` }), _jsx(Text, { color: stateColor(issue.blockedByCount > 0 && !issue.activeRunType ? "blocked" : issue.readyForExecution && !issue.activeRunType ? "ready" : issue.factoryState), children: ` ${status.padEnd(12)}` }), _jsx(Text, { dimColor: true, children: ` ${pr.padEnd(6)}` }), _jsx(Text, { dimColor: true, children: ` ${ago.padStart(3)}` }), title ? _jsx(Text, { dimColor: true, children: ` ${title}` }) : null] }), detail ? (_jsx(Box, { paddingLeft: 4, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: detail }) })) : null] }));
 }

package/dist/cli/watch/StatusBar.js

@@ -12,5 +12,5 @@ export function StatusBar({ issues, totalCount, filter, connected, lastServerMes
     const agg = computeAggregates(allIssues);
     const withPr = allIssues.filter((i) => i.prNumber !== undefined).length;
     const awaitingInput = allIssues.filter((i) => i.factoryState === "awaiting_input").length;
-    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { bold: true, children: showing }), _jsxs(Text, { dimColor: true, children: ["[", FILTER_LABELS[filter], "]"] }), _jsx(Text, { dimColor: true, children: "|" }), agg.active > 0 && _jsxs(Text, { color: "cyan", children: [agg.active, " active"] }), withPr > 0 && _jsxs(Text, { dimColor: true, children: [withPr, " PRs"] }), awaitingInput > 0 && _jsxs(Text, { color: "yellow", children: [awaitingInput, " awaiting input"] }), agg.done > 0 && _jsxs(Text, { color: "green", children: [agg.done, " done"] }), agg.failed > 0 && _jsxs(Text, { color: "red", children: [agg.failed, " failed"] })] }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }));
+    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { bold: true, children: showing }), _jsxs(Text, { dimColor: true, children: ["[", FILTER_LABELS[filter], "]"] }), _jsx(Text, { dimColor: true, children: "|" }), agg.active > 0 && _jsxs(Text, { color: "cyan", children: [agg.active, " active"] }), agg.ready > 0 && _jsxs(Text, { color: "blueBright", children: [agg.ready, " ready"] }), agg.blocked > 0 && _jsxs(Text, { color: "yellow", children: [agg.blocked, " blocked"] }), withPr > 0 && _jsxs(Text, { dimColor: true, children: [withPr, " PRs"] }), awaitingInput > 0 && _jsxs(Text, { color: "yellow", children: [awaitingInput, " awaiting input"] }), agg.done > 0 && _jsxs(Text, { color: "green", children: [agg.done, " done"] }), agg.failed > 0 && _jsxs(Text, { color: "red", children: [agg.failed, " failed"] })] }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }));
 }

package/dist/cli/watch/use-watch-stream.js

@@ -6,6 +6,19 @@ export function useWatchStream(options) {
         let abortController = new AbortController();
         let reconnectTimeout;
         let attempt = 0;
+        const fetchIssueSnapshot = async () => {
+            const { baseUrl, bearerToken, dispatch } = optionsRef.current;
+            const headers = { accept: "application/json" };
+            if (bearerToken) {
+                headers.authorization = `Bearer ${bearerToken}`;
+            }
+            const response = await fetch(new URL("/api/watch/issues", baseUrl), { headers });
+            if (!response.ok) {
+                throw new Error(`Issue snapshot failed: ${response.status}`);
+            }
+            const payload = await response.json();
+            dispatch({ type: "issues-snapshot", issues: Array.isArray(payload.issues) ? payload.issues : [], receivedAt: Date.now() });
+        };
         const connect = () => {
             abortController = new AbortController();
             const { baseUrl, bearerToken, issueFilter, dispatch } = optionsRef.current;
@@ -24,6 +37,12 @@ export function useWatchStream(options) {
                 }
                 dispatch({ type: "connected" });
                 attempt = 0;
+                try {
+                    await fetchIssueSnapshot();
+                }
+                catch {
+                    // Keep the stream alive even if the snapshot endpoint temporarily fails.
+                }
                 const reader = response.body.getReader();
                 const decoder = new TextDecoder();
                 let buffer = "";
@@ -80,11 +99,16 @@ export function useWatchStream(options) {
             });
         };
         connect();
+        void fetchIssueSnapshot().catch(() => undefined);
+        const snapshotInterval = setInterval(() => {
+            void fetchIssueSnapshot().catch(() => undefined);
+        }, 5000);
         return () => {
             abortController.abort();
             if (reconnectTimeout !== undefined) {
                 clearTimeout(reconnectTimeout);
             }
+            clearInterval(snapshotInterval);
         };
     }, []);
 }

package/dist/cli/watch/watch-state.js

@@ -46,17 +46,23 @@ const DONE_STATES = new Set(["done"]);
 const FAILED_STATES = new Set(["failed", "escalated"]);
 export function computeAggregates(issues) {
     let active = 0;
+    let blocked = 0;
+    let ready = 0;
     let done = 0;
     let failed = 0;
     for (const issue of issues) {
         if (issue.activeRunType)
             active++;
+        if (!issue.activeRunType && issue.blockedByCount > 0)
+            blocked++;
+        if (!issue.activeRunType && issue.readyForExecution)
+            ready++;
         if (DONE_STATES.has(issue.factoryState))
             done++;
         if (FAILED_STATES.has(issue.factoryState))
             failed++;
     }
-    return { active, done, failed, total: issues.length };
+    return { active, blocked, ready, done, failed, total: issues.length };
 }
 function nextFilter(filter) {
     switch (filter) {

package/dist/db/migrations.js

@@ -7,6 +7,7 @@ CREATE TABLE IF NOT EXISTS issues (
   title TEXT,
   url TEXT,
   current_linear_state TEXT,
+  current_linear_state_type TEXT,
   factory_state TEXT NOT NULL DEFAULT 'delegated',
   pending_run_type TEXT,
   pending_run_context_json TEXT,
@@ -145,6 +146,18 @@ CREATE TABLE IF NOT EXISTS operator_feed_events (
   status TEXT
 );
 
+CREATE TABLE IF NOT EXISTS issue_dependencies (
+  project_id TEXT NOT NULL,
+  linear_issue_id TEXT NOT NULL,
+  blocker_linear_issue_id TEXT NOT NULL,
+  blocker_issue_key TEXT,
+  blocker_title TEXT,
+  blocker_current_linear_state TEXT,
+  blocker_current_linear_state_type TEXT,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, linear_issue_id, blocker_linear_issue_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);
@@ -158,6 +171,8 @@ CREATE INDEX IF NOT EXISTS idx_operator_feed_events_project ON operator_feed_eve
 CREATE INDEX IF NOT EXISTS idx_repository_links_installation ON repository_links(installation_id, github_repo);
 CREATE INDEX IF NOT EXISTS idx_linear_catalog_teams_installation ON linear_catalog_teams(installation_id, team_key, team_name);
 CREATE INDEX IF NOT EXISTS idx_linear_catalog_projects_installation ON linear_catalog_projects(installation_id, project_name);
+CREATE INDEX IF NOT EXISTS idx_issue_dependencies_issue ON issue_dependencies(project_id, linear_issue_id);
+CREATE INDEX IF NOT EXISTS idx_issue_dependencies_blocker ON issue_dependencies(project_id, blocker_linear_issue_id);
 `;
 export function runPatchRelayMigrations(connection) {
     connection.exec(schema);
@@ -175,6 +190,8 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "description", "TEXT");
     addColumnIfMissing(connection, "issues", "priority", "INTEGER");
     addColumnIfMissing(connection, "issues", "estimate", "REAL");
+    addColumnIfMissing(connection, "issues", "current_linear_state_type", "TEXT");
+    addColumnIfMissing(connection, "issue_dependencies", "blocker_current_linear_state_type", "TEXT");
     // Zombie/stale recovery backoff
     addColumnIfMissing(connection, "issues", "zombie_recovery_attempts", "INTEGER NOT NULL DEFAULT 0");
     addColumnIfMissing(connection, "issues", "last_zombie_recovery_at", "TEXT");

package/dist/db/shared.js

@@ -66,6 +66,7 @@ export class SqliteConnection {
     savepointId = 0;
     constructor(path) {
         this.database = new DatabaseSync(path);
+        this.database.exec("PRAGMA busy_timeout = 5000");
     }
     close() {
         this.database.close();

package/dist/db.js

@@ -104,6 +104,10 @@ export class PatchRelayDatabase {
                 sets.push("current_linear_state = COALESCE(@currentLinearState, current_linear_state)");
                 values.currentLinearState = params.currentLinearState;
             }
+            if (params.currentLinearStateType !== undefined) {
+                sets.push("current_linear_state_type = COALESCE(@currentLinearStateType, current_linear_state_type)");
+                values.currentLinearStateType = params.currentLinearStateType;
+            }
             if (params.factoryState !== undefined) {
                 sets.push("factory_state = @factoryState");
                 values.factoryState = params.factoryState;
@@ -207,7 +211,7 @@ export class PatchRelayDatabase {
         INSERT INTO issues (
           project_id, linear_issue_id, issue_key, title, description, url,
           priority, estimate,
-          current_linear_state, factory_state, pending_run_type, pending_run_context_json,
+          current_linear_state, current_linear_state_type, factory_state, pending_run_type, pending_run_context_json,
           branch_name, worktree_path, thread_id, active_run_id,
           agent_session_id,
           pr_number, pr_url, pr_state, pr_review_state, pr_check_status,
@@ -216,7 +220,7 @@ export class PatchRelayDatabase {
         ) VALUES (
           @projectId, @linearIssueId, @issueKey, @title, @description, @url,
           @priority, @estimate,
-          @currentLinearState, @factoryState, @pendingRunType, @pendingRunContextJson,
+          @currentLinearState, @currentLinearStateType, @factoryState, @pendingRunType, @pendingRunContextJson,
           @branchName, @worktreePath, @threadId, @activeRunId,
           @agentSessionId,
           @prNumber, @prUrl, @prState, @prReviewState, @prCheckStatus,
@@ -233,6 +237,7 @@ export class PatchRelayDatabase {
                 priority: params.priority ?? null,
                 estimate: params.estimate ?? null,
                 currentLinearState: params.currentLinearState ?? null,
+                currentLinearStateType: params.currentLinearStateType ?? null,
                 factoryState: params.factoryState ?? "delegated",
                 pendingRunType: params.pendingRunType ?? null,
                 pendingRunContextJson: params.pendingRunContextJson ?? null,
@@ -279,9 +284,111 @@ export class PatchRelayDatabase {
         const row = this.connection.prepare("SELECT * FROM issues WHERE pr_number = ?").get(prNumber);
         return row ? mapIssueRow(row) : undefined;
     }
+    replaceIssueDependencies(params) {
+        const now = isoNow();
+        this.connection
+            .prepare("DELETE FROM issue_dependencies WHERE project_id = ? AND linear_issue_id = ?")
+            .run(params.projectId, params.linearIssueId);
+        if (params.blockers.length === 0) {
+            return;
+        }
+        const insert = this.connection.prepare(`
+      INSERT INTO issue_dependencies (
+        project_id,
+        linear_issue_id,
+        blocker_linear_issue_id,
+        blocker_issue_key,
+        blocker_title,
+        blocker_current_linear_state,
+        blocker_current_linear_state_type,
+        updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        for (const blocker of params.blockers) {
+            insert.run(params.projectId, params.linearIssueId, blocker.blockerLinearIssueId, blocker.blockerIssueKey ?? null, blocker.blockerTitle ?? null, blocker.blockerCurrentLinearState ?? null, blocker.blockerCurrentLinearStateType ?? null, now);
+        }
+    }
+    listIssueDependencies(projectId, linearIssueId) {
+        const rows = this.connection.prepare(`
+      SELECT
+        d.project_id,
+        d.linear_issue_id,
+        d.blocker_linear_issue_id,
+        COALESCE(blockers.issue_key, d.blocker_issue_key) AS blocker_issue_key,
+        COALESCE(blockers.title, d.blocker_title) AS blocker_title,
+        COALESCE(blockers.current_linear_state, d.blocker_current_linear_state) AS blocker_current_linear_state,
+        COALESCE(blockers.current_linear_state_type, d.blocker_current_linear_state_type) AS blocker_current_linear_state_type,
+        d.updated_at
+      FROM issue_dependencies d
+      LEFT JOIN issues blockers
+        ON blockers.project_id = d.project_id
+       AND blockers.linear_issue_id = d.blocker_linear_issue_id
+      WHERE d.project_id = ? AND d.linear_issue_id = ?
+      ORDER BY COALESCE(blockers.issue_key, d.blocker_issue_key, d.blocker_linear_issue_id) ASC
+    `).all(projectId, linearIssueId);
+        return rows.map((row) => ({
+            projectId: String(row.project_id),
+            linearIssueId: String(row.linear_issue_id),
+            blockerLinearIssueId: String(row.blocker_linear_issue_id),
+            ...(row.blocker_issue_key !== null && row.blocker_issue_key !== undefined ? { blockerIssueKey: String(row.blocker_issue_key) } : {}),
+            ...(row.blocker_title !== null && row.blocker_title !== undefined ? { blockerTitle: String(row.blocker_title) } : {}),
+            ...(row.blocker_current_linear_state !== null && row.blocker_current_linear_state !== undefined
+                ? { blockerCurrentLinearState: String(row.blocker_current_linear_state) }
+                : {}),
+            ...(row.blocker_current_linear_state_type !== null && row.blocker_current_linear_state_type !== undefined
+                ? { blockerCurrentLinearStateType: String(row.blocker_current_linear_state_type) }
+                : {}),
+            updatedAt: String(row.updated_at),
+        }));
+    }
+    listDependents(projectId, blockerLinearIssueId) {
+        const rows = this.connection.prepare(`
+      SELECT project_id, linear_issue_id
+      FROM issue_dependencies
+      WHERE project_id = ? AND blocker_linear_issue_id = ?
+      ORDER BY linear_issue_id ASC
+    `).all(projectId, blockerLinearIssueId);
+        return rows.map((row) => ({
+            projectId: String(row.project_id),
+            linearIssueId: String(row.linear_issue_id),
+        }));
+    }
+    countUnresolvedBlockers(projectId, linearIssueId) {
+        const row = this.connection.prepare(`
+      SELECT COUNT(*) AS count
+      FROM issue_dependencies d
+      LEFT JOIN issues blockers
+        ON blockers.project_id = d.project_id
+       AND blockers.linear_issue_id = d.blocker_linear_issue_id
+      WHERE d.project_id = ? AND d.linear_issue_id = ?
+        AND (
+          COALESCE(blockers.current_linear_state_type, d.blocker_current_linear_state_type, '') != 'completed'
+          AND LOWER(TRIM(COALESCE(blockers.current_linear_state, d.blocker_current_linear_state, ''))) != 'done'
+        )
+    `).get(projectId, linearIssueId);
+        return Number(row?.count ?? 0);
+    }
     listIssuesReadyForExecution() {
         const rows = this.connection
-            .prepare("SELECT project_id, linear_issue_id FROM issues WHERE pending_run_type IS NOT NULL AND active_run_id IS NULL")
+            .prepare(`
+        SELECT i.project_id, i.linear_issue_id
+        FROM issues i
+        WHERE i.pending_run_type IS NOT NULL
+          AND i.active_run_id IS NULL
+          AND NOT EXISTS (
+            SELECT 1
+            FROM issue_dependencies d
+            LEFT JOIN issues blockers
+              ON blockers.project_id = d.project_id
+             AND blockers.linear_issue_id = d.blocker_linear_issue_id
+            WHERE d.project_id = i.project_id
+              AND d.linear_issue_id = i.linear_issue_id
+              AND (
+                COALESCE(blockers.current_linear_state_type, d.blocker_current_linear_state_type, '') != 'completed'
+                AND LOWER(TRIM(COALESCE(blockers.current_linear_state, d.blocker_current_linear_state, ''))) != 'done'
+              )
+          )
+      `)
             .all();
         return rows.map((row) => ({
             projectId: String(row.project_id),
@@ -399,6 +506,8 @@ export class PatchRelayDatabase {
     }
     // ─── View builders ──────────────────────────────────────────────
     issueToTrackedIssue(issue) {
+        const blockedBy = this.listIssueDependencies(issue.projectId, issue.linearIssueId);
+        const unresolvedBlockedBy = blockedBy.filter((entry) => !isResolvedLinearState(entry.blockerCurrentLinearStateType, entry.blockerCurrentLinearState));
         return {
             id: issue.id,
             projectId: issue.projectId,
@@ -408,6 +517,10 @@ export class PatchRelayDatabase {
             ...(issue.url ? { issueUrl: issue.url } : {}),
             ...(issue.currentLinearState ? { currentLinearState: issue.currentLinearState } : {}),
             factoryState: issue.factoryState,
+            blockedByCount: unresolvedBlockedBy.length,
+            blockedByKeys: unresolvedBlockedBy
+                .map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId),
+            readyForExecution: issue.pendingRunType !== undefined && issue.activeRunId === undefined && unresolvedBlockedBy.length === 0,
             ...(issue.activeRunId !== undefined ? { activeRunId: issue.activeRunId } : {}),
             ...(issue.agentSessionId ? { activeAgentSessionId: issue.agentSessionId } : {}),
             updatedAt: issue.updatedAt,
@@ -447,6 +560,9 @@ function mapIssueRow(row) {
         ...(row.priority !== null && row.priority !== undefined ? { priority: Number(row.priority) } : {}),
         ...(row.estimate !== null && row.estimate !== undefined ? { estimate: Number(row.estimate) } : {}),
         ...(row.current_linear_state !== null ? { currentLinearState: String(row.current_linear_state) } : {}),
+        ...(row.current_linear_state_type !== null && row.current_linear_state_type !== undefined
+            ? { currentLinearStateType: String(row.current_linear_state_type) }
+            : {}),
         factoryState: String(row.factory_state ?? "delegated"),
         ...(row.pending_run_type !== null && row.pending_run_type !== undefined ? { pendingRunType: String(row.pending_run_type) } : {}),
         ...(row.pending_run_context_json !== null && row.pending_run_context_json !== undefined ? { pendingRunContextJson: String(row.pending_run_context_json) } : {}),
@@ -505,3 +621,6 @@ function mapRunRow(row) {
         ...(row.ended_at !== null ? { endedAt: String(row.ended_at) } : {}),
     };
 }
+function isResolvedLinearState(stateType, stateName) {
+    return stateType === "completed" || stateName?.trim().toLowerCase() === "done";
+}

package/dist/http.js

@@ -378,6 +378,9 @@ export async function buildHttpServer(config, service, logger) {
             reply.raw.on("error", cleanup);
             request.raw.on("close", cleanup);
         });
+        app.get("/api/watch/issues", async (_request, reply) => {
+            return reply.send({ ok: true, issues: service.listTrackedIssues() });
+        });
         app.get("/api/watch", async (request, reply) => {
             reply.hijack();
             reply.raw.writeHead(200, {

package/dist/linear-client.js

@@ -1,5 +1,70 @@
 import { refreshLinearOAuthToken } from "./linear-oauth.js";
 import { decryptSecret, encryptSecret } from "./token-crypto.js";
+const LINEAR_ISSUE_SELECTION = `
+  id
+  identifier
+  title
+  description
+  url
+  priority
+  estimate
+  delegate {
+    id
+    name
+  }
+  state {
+    id
+    name
+    type
+  }
+  labels {
+    nodes {
+      id
+      name
+    }
+  }
+  blockedBy {
+    nodes {
+      id
+      identifier
+      title
+      state {
+        id
+        name
+        type
+      }
+    }
+  }
+  blocks {
+    nodes {
+      id
+      identifier
+      title
+      state {
+        id
+        name
+        type
+      }
+    }
+  }
+  team {
+    id
+    key
+    states {
+      nodes {
+        id
+        name
+        type
+      }
+    }
+    labels {
+      nodes {
+        id
+        name
+      }
+    }
+  }
+`;
 export class LinearGraphqlClient {
     options;
     logger;
@@ -11,44 +76,7 @@ export class LinearGraphqlClient {
         const response = await this.request(`
       query PatchRelayIssue($id: String!) {
         issue(id: $id) {
-          id
-          identifier
-          title
-          description
-          url
-          priority
-          estimate
-          delegate {
-            id
-            name
-          }
-          state {
-            id
-            name
-          }
-          labels {
-            nodes {
-              id
-              name
-            }
-          }
-          team {
-            id
-            key
-            states {
-              nodes {
-                id
-                name
-                type
-              }
-            }
-            labels {
-              nodes {
-                id
-                name
-              }
-            }
-          }
+          ${LINEAR_ISSUE_SELECTION}
         }
       }
       `, { id: issueId });
@@ -68,44 +96,7 @@ export class LinearGraphqlClient {
         issueUpdate(id: $id, input: { stateId: $stateId }) {
           success
           issue {
-            id
-            identifier
-            title
-            description
-            url
-            priority
-            estimate
-            delegate {
-              id
-              name
-            }
-            state {
-              id
-              name
-            }
-            labels {
-              nodes {
-                id
-                name
-              }
-            }
-            team {
-              id
-              key
-              states {
-                nodes {
-                  id
-                  name
-                  type
-                }
-              }
-              labels {
-                nodes {
-                  id
-                  name
-                }
-              }
-            }
+            ${LINEAR_ISSUE_SELECTION}
           }
         }
       }
@@ -208,40 +199,7 @@ export class LinearGraphqlClient {
         issueUpdate(id: $id, input: { addedLabelIds: $addedLabelIds, removedLabelIds: $removedLabelIds }) {
           success
           issue {
-            id
-            identifier
-            title
-            description
-            url
-            priority
-            estimate
-            state {
-              id
-              name
-            }
-            labels {
-              nodes {
-                id
-                name
-              }
-            }
-            team {
-              id
-              key
-              states {
-                nodes {
-                  id
-                  name
-                  type
-                }
-              }
-              labels {
-                nodes {
-                  id
-                  name
-                }
-              }
-            }
+            ${LINEAR_ISSUE_SELECTION}
           }
         }
       }
@@ -360,6 +318,7 @@ export class LinearGraphqlClient {
             ...(issue.estimate != null ? { estimate: issue.estimate } : {}),
             ...(issue.state?.id ? { stateId: issue.state.id } : {}),
             ...(issue.state?.name ? { stateName: issue.state.name } : {}),
+            ...(issue.state?.type ? { stateType: issue.state.type } : {}),
             ...(issue.team?.id ? { teamId: issue.team.id } : {}),
             ...(issue.team?.key ? { teamKey: issue.team.key } : {}),
             ...(issue.delegate?.id ? { delegateId: issue.delegate.id } : {}),
@@ -372,6 +331,8 @@ export class LinearGraphqlClient {
             labelIds: labels.map((label) => label.id),
             labels,
             teamLabels,
+            blockedBy: (issue.blockedBy?.nodes ?? []).map(mapIssueRelation),
+            blocks: (issue.blocks?.nodes ?? []).map(mapIssueRelation),
         };
     }
     resolveLabelIds(issue, names) {
@@ -389,6 +350,16 @@ export class LinearGraphqlClient {
         return labelIds;
     }
 }
+function mapIssueRelation(raw) {
+    return {
+        id: raw.id,
+        ...(raw.identifier ? { identifier: raw.identifier } : {}),
+        ...(raw.title ? { title: raw.title } : {}),
+        ...(raw.state?.id ? { stateId: raw.state.id } : {}),
+        ...(raw.state?.name ? { stateName: raw.state.name } : {}),
+        ...(raw.state?.type ? { stateType: raw.state.type } : {}),
+    };
+}
 export class DatabaseBackedLinearClientProvider {
     config;
     db;

package/dist/service.js

@@ -214,12 +214,39 @@ export class PatchRelayService {
             .prepare(`SELECT
           i.project_id, i.linear_issue_id, i.issue_key, i.title,
           i.current_linear_state, i.factory_state, i.updated_at,
+          i.pending_run_type,
           i.pr_number, i.pr_review_state, i.pr_check_status,
           active_run.run_type AS active_run_type,
           latest_run.run_type AS latest_run_type,
           latest_run.status AS latest_run_status,
           latest_run.summary_json AS latest_run_summary_json,
-          latest_run.report_json AS latest_run_report_json
+          latest_run.report_json AS latest_run_report_json,
+          (
+            SELECT COUNT(*)
+            FROM issue_dependencies d
+            LEFT JOIN issues blockers
+              ON blockers.project_id = d.project_id
+             AND blockers.linear_issue_id = d.blocker_linear_issue_id
+            WHERE d.project_id = i.project_id
+              AND d.linear_issue_id = i.linear_issue_id
+              AND (
+                COALESCE(blockers.current_linear_state_type, d.blocker_current_linear_state_type, '') != 'completed'
+                AND LOWER(TRIM(COALESCE(blockers.current_linear_state, d.blocker_current_linear_state, ''))) != 'done'
+              )
+          ) AS blocked_by_count,
+          (
+            SELECT json_group_array(COALESCE(blockers.issue_key, d.blocker_issue_key, d.blocker_linear_issue_id))
+            FROM issue_dependencies d
+            LEFT JOIN issues blockers
+              ON blockers.project_id = d.project_id
+             AND blockers.linear_issue_id = d.blocker_linear_issue_id
+            WHERE d.project_id = i.project_id
+              AND d.linear_issue_id = i.linear_issue_id
+              AND (
+                COALESCE(blockers.current_linear_state_type, d.blocker_current_linear_state_type, '') != 'completed'
+                AND LOWER(TRIM(COALESCE(blockers.current_linear_state, d.blocker_current_linear_state, ''))) != 'done'
+              )
+          ) AS blocked_by_keys_json
         FROM issues i
         LEFT JOIN runs active_run ON active_run.id = i.active_run_id
         LEFT JOIN runs latest_run ON latest_run.id = (
@@ -231,14 +258,24 @@ export class PatchRelayService {
             .all();
         return rows.map((row) => {
             const statusNote = extractStatusNote(typeof row.latest_run_summary_json === "string" ? row.latest_run_summary_json : undefined, typeof row.latest_run_report_json === "string" ? row.latest_run_report_json : undefined);
+            const blockedByKeys = parseStringArray(typeof row.blocked_by_keys_json === "string" ? row.blocked_by_keys_json : undefined);
+            const blockedByCount = Number(row.blocked_by_count ?? 0);
+            const readyForExecution = row.pending_run_type !== null && row.pending_run_type !== undefined && row.active_run_type === null && blockedByCount === 0;
+            const statusNoteWithBlockers = blockedByCount > 0
+                ? `Blocked by ${blockedByKeys.join(", ")}`
+                : statusNote;
             return {
                 ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
                 ...(row.title !== null ? { title: String(row.title) } : {}),
-                ...(statusNote ? { statusNote } : {}),
+                ...(statusNoteWithBlockers ? { statusNote: statusNoteWithBlockers } : {}),
                 projectId: String(row.project_id),
                 factoryState: String(row.factory_state ?? "delegated"),
+                blockedByCount,
+                blockedByKeys,
+                readyForExecution,
                 ...(row.current_linear_state !== null ? { currentLinearState: String(row.current_linear_state) } : {}),
                 ...(row.active_run_type !== null ? { activeRunType: String(row.active_run_type) } : {}),
+                ...(row.pending_run_type !== null ? { pendingRunType: String(row.pending_run_type) } : {}),
                 ...(row.latest_run_type !== null ? { latestRunType: String(row.latest_run_type) } : {}),
                 ...(row.latest_run_status !== null ? { latestRunStatus: String(row.latest_run_status) } : {}),
                 ...(row.pr_number !== null ? { prNumber: Number(row.pr_number) } : {}),

package/dist/webhook-handler.js

@@ -94,8 +94,9 @@ export class WebhookHandler {
             const hydrated = await this.hydrateIssueContext(project.id, normalized);
             const issue = hydrated.issue ?? routedIssue;
             // Record desired stage and upsert issue
-            const result = this.recordDesiredStage(project, hydrated);
+            const result = await this.recordDesiredStage(project, hydrated);
             const trackedIssue = result.issue;
+            const newlyReadyDependents = this.reconcileDependentReadiness(project.id, issue.id);
             // Handle agent session events
             await this.handleAgentSession(hydrated, project, trackedIssue, result.desiredStage, result.delegated);
             // Handle comments during active run
@@ -114,6 +115,20 @@ export class WebhookHandler {
                 });
                 this.enqueueIssue(project.id, issue.id);
             }
+            for (const dependentIssueId of newlyReadyDependents) {
+                const dependent = this.db.getTrackedIssue(project.id, dependentIssueId);
+                this.feed?.publish({
+                    level: "info",
+                    kind: "stage",
+                    issueKey: dependent?.issueKey,
+                    projectId: project.id,
+                    stage: "implementation",
+                    status: "queued",
+                    summary: "Queued implementation after blockers resolved",
+                    detail: `All blockers are now done for ${dependent?.issueKey ?? dependentIssueId}.`,
+                });
+                this.enqueueIssue(project.id, dependentIssueId);
+            }
         }
         catch (error) {
             this.db.markWebhookProcessed(webhookEventId, "failed");
@@ -130,7 +145,7 @@ export class WebhookHandler {
             throw err;
         }
     }
-    recordDesiredStage(project, normalized) {
+    async recordDesiredStage(project, normalized) {
         const normalizedIssue = normalized.issue;
         if (!normalizedIssue) {
             return { issue: undefined, desiredStage: undefined, delegated: false };
@@ -139,19 +154,18 @@ export class WebhookHandler {
         const activeRun = existingIssue?.activeRunId ? this.db.getRun(existingIssue.activeRunId) : undefined;
         const delegated = this.isDelegatedToPatchRelay(project, normalized);
         const triggerAllowed = triggerEventAllowed(project, normalized.triggerEvent);
+        const shouldTrack = Boolean(existingIssue || delegated);
+        if (!shouldTrack) {
+            return { issue: undefined, desiredStage: undefined, delegated };
+        }
+        const hydratedIssue = await this.syncIssueDependencies(project.id, normalizedIssue);
+        const unresolvedBlockers = this.db.countUnresolvedBlockers(project.id, normalizedIssue.id);
         const pendingRunContextJson = mergePendingImplementationContext(existingIssue?.pendingRunContextJson, normalized);
-        // In the factory model, only a true delegation queues implementation work.
         let pendingRunType;
-        const isDelegationSignal = delegated;
-        if (isDelegationSignal && triggerAllowed && !activeRun && !existingIssue?.pendingRunType) {
+        if (delegated && triggerAllowed && unresolvedBlockers === 0 && !activeRun && !existingIssue?.pendingRunType) {
             pendingRunType = "implementation";
         }
-        // Do not create tracked issue rows for unrelated Linear traffic.
-        // An issue becomes PatchRelay-relevant only once it is already tracked
-        // or a true delegation queues work.
-        if (!existingIssue && !pendingRunType) {
-            return { issue: undefined, desiredStage: undefined, delegated };
-        }
+        const clearPendingImplementation = unresolvedBlockers > 0 && existingIssue?.pendingRunType === "implementation" && !activeRun;
         // Resolve agent session
         const agentSessionId = normalized.agentSession?.id ??
             (!activeRun && (pendingRunType || (normalized.triggerEvent === "delegateChanged" && !delegated)) ? null : undefined);
@@ -159,14 +173,16 @@ export class WebhookHandler {
         const issue = this.db.upsertIssue({
             projectId: project.id,
             linearIssueId: normalizedIssue.id,
-            ...(normalizedIssue.identifier ? { issueKey: normalizedIssue.identifier } : {}),
-            ...(normalizedIssue.title ? { title: normalizedIssue.title } : {}),
-            ...(normalizedIssue.description ? { description: normalizedIssue.description } : {}),
-            ...(normalizedIssue.url ? { url: normalizedIssue.url } : {}),
-            ...(normalizedIssue.priority != null ? { priority: normalizedIssue.priority } : {}),
-            ...(normalizedIssue.estimate != null ? { estimate: normalizedIssue.estimate } : {}),
-            ...(normalizedIssue.stateName ? { currentLinearState: normalizedIssue.stateName } : {}),
+            ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
+            ...(hydratedIssue.title ? { title: hydratedIssue.title } : {}),
+            ...(hydratedIssue.description ? { description: hydratedIssue.description } : {}),
+            ...(hydratedIssue.url ? { url: hydratedIssue.url } : {}),
+            ...(hydratedIssue.priority != null ? { priority: hydratedIssue.priority } : {}),
+            ...(hydratedIssue.estimate != null ? { estimate: hydratedIssue.estimate } : {}),
+            ...(hydratedIssue.stateName ? { currentLinearState: hydratedIssue.stateName } : {}),
+            ...(hydratedIssue.stateType ? { currentLinearStateType: hydratedIssue.stateType } : {}),
             ...(pendingRunType ? { pendingRunType, factoryState: "delegated" } : {}),
+            ...(clearPendingImplementation ? { pendingRunType: null } : {}),
             ...((pendingRunType || existingIssue?.pendingRunType === "implementation") && pendingRunContextJson
                 ? { pendingRunContextJson }
                 : {}),
@@ -186,6 +202,64 @@ export class WebhookHandler {
             return false;
         return normalized.issue.delegateId === installation.actorId;
     }
+    async syncIssueDependencies(projectId, issue) {
+        let source = issue;
+        if (!source.relationsKnown) {
+            const linear = await this.linearProvider.forProject(projectId);
+            if (linear) {
+                try {
+                    source = mergeIssueMetadata(source, await linear.getIssue(issue.id));
+                }
+                catch {
+                    // Preserve existing dependency rows when webhook relation data is incomplete.
+                }
+            }
+        }
+        if (source.relationsKnown) {
+            this.db.replaceIssueDependencies({
+                projectId,
+                linearIssueId: source.id,
+                blockers: source.blockedBy.map((blocker) => ({
+                    blockerLinearIssueId: blocker.id,
+                    ...(blocker.identifier ? { blockerIssueKey: blocker.identifier } : {}),
+                    ...(blocker.title ? { blockerTitle: blocker.title } : {}),
+                    ...(blocker.stateName ? { blockerCurrentLinearState: blocker.stateName } : {}),
+                    ...(blocker.stateType ? { blockerCurrentLinearStateType: blocker.stateType } : {}),
+                })),
+            });
+        }
+        return source;
+    }
+    reconcileDependentReadiness(projectId, blockerLinearIssueId) {
+        const newlyReady = [];
+        for (const dependent of this.db.listDependents(projectId, blockerLinearIssueId)) {
+            const issue = this.db.getIssue(projectId, dependent.linearIssueId);
+            if (!issue) {
+                continue;
+            }
+            const unresolved = this.db.countUnresolvedBlockers(projectId, dependent.linearIssueId);
+            if (unresolved > 0) {
+                if (issue.pendingRunType === "implementation" && issue.activeRunId === undefined) {
+                    this.db.upsertIssue({
+                        projectId,
+                        linearIssueId: dependent.linearIssueId,
+                        pendingRunType: null,
+                    });
+                }
+                continue;
+            }
+            if (issue.factoryState !== "delegated" || issue.activeRunId !== undefined || issue.pendingRunType !== undefined) {
+                continue;
+            }
+            this.db.upsertIssue({
+                projectId,
+                linearIssueId: dependent.linearIssueId,
+                pendingRunType: "implementation",
+            });
+            newlyReady.push(dependent.linearIssueId);
+        }
+        return newlyReady;
+    }
     // ─── Agent session handling (inlined) ─────────────────────────────
     async handleAgentSession(normalized, project, trackedIssue, desiredStage, delegated) {
         if (!normalized.agentSession?.id || !normalized.issue)
@@ -213,9 +287,12 @@ export class WebhookHandler {
                 await this.publishAgentActivity(linear, normalized.agentSession.id, buildAlreadyRunningThought(activeRun.runType));
                 return;
             }
+            const blockerSummary = trackedIssue?.blockedByCount
+                ? `PatchRelay is delegated and waiting on blockers to reach Done: ${trackedIssue.blockedByKeys.join(", ")}.`
+                : "PatchRelay is delegated, but no work is queued. Delegate the issue or move it to Start to trigger implementation.";
             await this.publishAgentActivity(linear, normalized.agentSession.id, {
                 type: "elicitation",
-                body: "PatchRelay is delegated, but no work is queued. Delegate the issue or move it to Start to trigger implementation.",
+                body: blockerSummary,
             });
             return;
         }
@@ -423,9 +500,10 @@ export class WebhookHandler {
     async hydrateIssueContext(projectId, normalized) {
         if (!normalized.issue)
             return normalized;
-        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted")
+        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted" && normalized.entityType !== "Issue") {
             return normalized;
-        if (hasCompleteIssueContext(normalized.issue))
+        }
+        if (normalized.entityType !== "Issue" && hasCompleteIssueContext(normalized.issue))
             return normalized;
         const linear = await this.linearProvider.forProject(projectId);
         if (!linear)
@@ -485,8 +563,12 @@ function mergeIssueMetadata(issue, liveIssue) {
         ...(issue.teamKey ? {} : liveIssue.teamKey ? { teamKey: liveIssue.teamKey } : {}),
         ...(issue.stateId ? {} : liveIssue.stateId ? { stateId: liveIssue.stateId } : {}),
         ...(issue.stateName ? {} : liveIssue.stateName ? { stateName: liveIssue.stateName } : {}),
+        ...(issue.stateType ? {} : liveIssue.stateType ? { stateType: liveIssue.stateType } : {}),
         ...(issue.delegateId ? {} : liveIssue.delegateId ? { delegateId: liveIssue.delegateId } : {}),
         ...(issue.delegateName ? {} : liveIssue.delegateName ? { delegateName: liveIssue.delegateName } : {}),
+        relationsKnown: issue.relationsKnown || liveIssue.blockedBy !== undefined || liveIssue.blocks !== undefined,
         labelNames: issue.labelNames.length > 0 ? issue.labelNames : (liveIssue.labels ?? []).map((l) => l.name),
+        blockedBy: issue.relationsKnown ? issue.blockedBy : (liveIssue.blockedBy ?? issue.blockedBy),
+        blocks: issue.relationsKnown ? issue.blocks : (liveIssue.blocks ?? issue.blocks),
     };
 }

package/dist/webhooks.js

@@ -80,12 +80,12 @@ function deriveTriggerEvent(payload) {
         if (updatedFields.has("stateId") || updatedFields.has("state")) {
             return "statusChanged";
         }
-        if (updatedFields.has("assigneeId") || updatedFields.has("assignee")) {
-            return "assignmentChanged";
-        }
         if (updatedFields.has("delegateId") || updatedFields.has("delegate")) {
             return "delegateChanged";
         }
+        if (updatedFields.has("assigneeId") || updatedFields.has("assignee")) {
+            return "assignmentChanged";
+        }
         return "issueUpdated";
     }
     if (payload.type === "Comment") {
@@ -227,7 +227,10 @@ function extractIssueMetadata(payload) {
         ...(delegateName ? { delegateName } : {}),
         ...(priority != null ? { priority } : {}),
         ...(estimate != null ? { estimate } : {}),
+        relationsKnown: false,
         labelNames: extractLabelNames(issueRecord),
+        blockedBy: [],
+        blocks: [],
     };
 }
 function extractActorFromRecord(record) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.29.3",
+  "version": "0.30.1",
   "license": "MIT",
   "type": "module",
   "repository": {