patchrelay 0.74.6 → 0.74.7

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.74.6",
-  "commit": "4c5efe0939d1",
-  "builtAt": "2026-05-29T08:45:52.226Z"
+  "version": "0.74.7",
+  "commit": "53cd46e337f8",
+  "builtAt": "2026-05-29T11:49:02.626Z"
 }

package/dist/db/issue-session-store.js

@@ -1,5 +1,6 @@
 import { deriveSessionWakePlan, isActionableIssueSessionEventType } from "../issue-session-events.js";
 import { mergeRequestedChangesEventJson, readRequestedChangesCoalesceKey } from "../reactive-wake-keys.js";
+import { emitTelemetry, noopTelemetry } from "../telemetry.js";
 import { isoNow } from "./shared.js";
 export class IssueSessionStore {
     connection;
@@ -7,12 +8,16 @@ export class IssueSessionStore {
     mapIssueSessionEventRow;
     issues;
     runs;
-    constructor(connection, mapIssueSessionRow, mapIssueSessionEventRow, issues, runs) {
+    issueSessionProjection;
+    telemetry;
+    constructor(connection, mapIssueSessionRow, mapIssueSessionEventRow, issues, runs, issueSessionProjection, telemetry = noopTelemetry) {
         this.connection = connection;
         this.mapIssueSessionRow = mapIssueSessionRow;
         this.mapIssueSessionEventRow = mapIssueSessionEventRow;
         this.issues = issues;
         this.runs = runs;
+        this.issueSessionProjection = issueSessionProjection;
+        this.telemetry = telemetry;
     }
     getIssueSession(projectId, linearIssueId) {
         const row = this.connection
@@ -31,19 +36,25 @@ export class IssueSessionStore {
         WHERE project_id = ? AND linear_issue_id = ? AND dedupe_key = ? AND processed_at IS NULL
         ORDER BY id DESC LIMIT 1
       `).get(params.projectId, params.linearIssueId, params.dedupeKey);
-            if (existing)
+            if (existing) {
+                this.issueSessionProjection.issueSessionEventsChanged(params.projectId, params.linearIssueId);
                 return this.mapIssueSessionEventRow(existing);
+            }
         }
         const coalesced = this.coalescePendingRequestedChangesEvent(params);
-        if (coalesced)
+        if (coalesced) {
+            this.issueSessionProjection.issueSessionEventsChanged(params.projectId, params.linearIssueId);
             return coalesced;
+        }
         const now = isoNow();
         const result = this.connection.prepare(`
       INSERT INTO issue_session_events (
         project_id, linear_issue_id, event_type, event_json, dedupe_key, created_at
       ) VALUES (?, ?, ?, ?, ?, ?)
     `).run(params.projectId, params.linearIssueId, params.eventType, params.eventJson ?? null, params.dedupeKey ?? null, now);
-        return this.getIssueSessionEvent(Number(result.lastInsertRowid));
+        const event = this.getIssueSessionEvent(Number(result.lastInsertRowid));
+        this.issueSessionProjection.issueSessionEventsChanged(params.projectId, params.linearIssueId);
+        return event;
     }
     coalescePendingRequestedChangesEvent(params) {
         if (params.eventType !== "review_changes_requested")
@@ -104,6 +115,16 @@ export class IssueSessionStore {
       SET processed_at = ?, consumed_by_run_id = ?
       WHERE project_id = ? AND linear_issue_id = ? AND id IN (${placeholders}) AND processed_at IS NULL
     `).run(now, runId, projectId, linearIssueId, ...eventIds);
+        this.issueSessionProjection.issueSessionEventsChanged(projectId, linearIssueId);
+        const issue = this.issues.getIssue(projectId, linearIssueId);
+        emitTelemetry(this.telemetry, {
+            type: "wake.consumed",
+            projectId,
+            linearIssueId,
+            ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
+            eventIds,
+            runId,
+        });
     }
     dismissIssueSessionEvents(projectId, linearIssueId, eventIds) {
         if (eventIds.length === 0)
@@ -114,13 +135,34 @@ export class IssueSessionStore {
       SET processed_at = ?, consumed_by_run_id = NULL
       WHERE project_id = ? AND linear_issue_id = ? AND id IN (${placeholders}) AND processed_at IS NULL
     `).run(isoNow(), projectId, linearIssueId, ...eventIds);
+        this.issueSessionProjection.issueSessionEventsChanged(projectId, linearIssueId);
+        const issue = this.issues.getIssue(projectId, linearIssueId);
+        emitTelemetry(this.telemetry, {
+            type: "wake.dismissed",
+            projectId,
+            linearIssueId,
+            ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
+            eventIds,
+            reason: "dismissed",
+        });
     }
     clearPendingIssueSessionEvents(projectId, linearIssueId) {
+        const eventIds = this.listIssueSessionEvents(projectId, linearIssueId, { pendingOnly: true }).map((event) => event.id);
         this.connection.prepare(`
       UPDATE issue_session_events
       SET processed_at = ?, consumed_by_run_id = NULL
       WHERE project_id = ? AND linear_issue_id = ? AND processed_at IS NULL
     `).run(isoNow(), projectId, linearIssueId);
+        this.issueSessionProjection.issueSessionEventsChanged(projectId, linearIssueId);
+        const issue = this.issues.getIssue(projectId, linearIssueId);
+        emitTelemetry(this.telemetry, {
+            type: "wake.dismissed",
+            projectId,
+            linearIssueId,
+            ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
+            eventIds,
+            reason: "cleared_pending",
+        });
     }
     hasPendingIssueSessionEvents(projectId, linearIssueId) {
         return this.listIssueSessionEvents(projectId, linearIssueId, { pendingOnly: true })

package/dist/db/issue-store.js

@@ -10,10 +10,10 @@ const OPEN_CHILD_PREDICATE = `
 `;
 export class IssueStore {
     connection;
-    syncIssueSessionFromIssue;
-    constructor(connection, syncIssueSessionFromIssue) {
+    issueSessionProjection;
+    constructor(connection, issueSessionProjection) {
         this.connection = connection;
-        this.syncIssueSessionFromIssue = syncIssueSessionFromIssue;
+        this.issueSessionProjection = issueSessionProjection;
     }
     upsertIssue(params) {
         const now = isoNow();
@@ -39,7 +39,7 @@ export class IssueStore {
             });
         }
         const updated = this.getIssue(params.projectId, params.linearIssueId);
-        this.syncIssueSessionFromIssue(updated);
+        this.issueSessionProjection.issueChanged(updated);
         return updated;
     }
     getIssue(projectId, linearIssueId) {
@@ -163,6 +163,7 @@ export class IssueStore {
             .prepare("DELETE FROM issue_dependencies WHERE project_id = ? AND linear_issue_id = ?")
             .run(params.projectId, params.linearIssueId);
         if (params.blockers.length === 0) {
+            this.issueSessionProjection.issueDependenciesChanged(params.projectId, params.linearIssueId);
             return;
         }
         const insert = this.connection.prepare(`
@@ -180,6 +181,7 @@ export class IssueStore {
         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);
         }
+        this.issueSessionProjection.issueDependenciesChanged(params.projectId, params.linearIssueId);
     }
     updateDependencyBlockerSnapshot(params) {
         const sets = ["updated_at = @now"];
@@ -210,6 +212,9 @@ export class IssueStore {
       WHERE project_id = @projectId
         AND blocker_linear_issue_id = @blockerLinearIssueId
     `).run(values);
+        if (Number(result.changes) > 0) {
+            this.issueSessionProjection.dependencyBlockerChanged(params.projectId, params.blockerLinearIssueId);
+        }
         return Number(result.changes);
     }
     listIssueDependencies(projectId, linearIssueId) {

package/dist/db/run-store.js

@@ -1,15 +1,21 @@
 import { extractLatestAssistantSummary } from "../issue-session-events.js";
+import { emitTelemetry, noopTelemetry } from "../telemetry.js";
 import { isoNow } from "./shared.js";
 export class RunStore {
     connection;
     mapRunRow;
     issues;
-    syncIssueSessionFromIssue;
-    constructor(connection, mapRunRow, issues, syncIssueSessionFromIssue) {
+    issueSessionProjection;
+    telemetry;
+    constructor(connection, mapRunRow, issues, issueSessionProjection, telemetry = noopTelemetry) {
         this.connection = connection;
         this.mapRunRow = mapRunRow;
         this.issues = issues;
-        this.syncIssueSessionFromIssue = syncIssueSessionFromIssue;
+        this.issueSessionProjection = issueSessionProjection;
+        this.telemetry = telemetry;
+    }
+    projectIssueRun(issue, options) {
+        this.issueSessionProjection.issueRunChanged(issue, options);
     }
     createRun(params) {
         const now = isoNow();
@@ -20,8 +26,16 @@ export class RunStore {
         const run = this.getRunById(Number(result.lastInsertRowid));
         const issue = this.issues.getIssue(params.projectId, params.linearIssueId);
         if (issue) {
-            this.syncIssueSessionFromIssue(issue, { lastRunType: run.runType });
+            this.projectIssueRun(issue, { lastRunType: run.runType });
         }
+        emitTelemetry(this.telemetry, {
+            type: "run.claimed",
+            projectId: params.projectId,
+            linearIssueId: params.linearIssueId,
+            runId: run.id,
+            runType: run.runType,
+            ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
+        });
         return run;
     }
     getRunById(id) {
@@ -72,8 +86,16 @@ export class RunStore {
             return;
         const issue = this.issues.getIssue(run.projectId, run.linearIssueId);
         if (issue) {
-            this.syncIssueSessionFromIssue(issue);
+            this.projectIssueRun(issue);
         }
+        emitTelemetry(this.telemetry, {
+            type: "run.started",
+            projectId: run.projectId,
+            linearIssueId: run.linearIssueId,
+            runId: run.id,
+            runType: run.runType,
+            ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
+        });
     }
     updateRunTurnId(runId, turnId) {
         this.connection.prepare("UPDATE runs SET turn_id = ? WHERE id = ?").run(turnId, runId);
@@ -96,11 +118,25 @@ export class RunStore {
             return;
         const issue = this.issues.getIssue(run.projectId, run.linearIssueId);
         if (issue) {
-            this.syncIssueSessionFromIssue(issue, {
+            this.projectIssueRun(issue, {
                 summaryText: extractLatestAssistantSummary(this.getRunById(runId) ?? run),
                 lastRunType: run.runType,
             });
         }
+        emitTelemetry(this.telemetry, {
+            type: params.status === "completed"
+                ? "run.completed"
+                : params.status === "released"
+                    ? "run.released"
+                    : params.status === "superseded"
+                        ? "run.superseded"
+                        : "run.failed",
+            projectId: run.projectId,
+            linearIssueId: run.linearIssueId,
+            runId: run.id,
+            runType: run.runType,
+            ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
+        });
     }
     // Plan §4.4: flag a still-running run as superseded. We deliberately
     // do NOT change `status` here — the Codex turn must finish naturally
@@ -124,7 +160,7 @@ export class RunStore {
             return;
         const issue = this.issues.getIssue(run.projectId, run.linearIssueId);
         if (issue) {
-            this.syncIssueSessionFromIssue(issue, {
+            this.projectIssueRun(issue, {
                 summaryText: params.reason,
                 lastRunType: run.runType,
             });
@@ -157,7 +193,7 @@ export class RunStore {
             return;
         const issue = this.issues.getIssue(run.projectId, run.linearIssueId);
         if (issue) {
-            this.syncIssueSessionFromIssue(issue, {
+            this.projectIssueRun(issue, {
                 lastRunType: run.runType,
             });
         }

package/dist/db.js

@@ -9,11 +9,17 @@ import { WebhookEventStore } from "./db/webhook-event-store.js";
 import { runPatchRelayMigrations } from "./db/migrations.js";
 import { assertPatchRelaySchemaReady } from "./db/schema-guard.js";
 import { SqliteConnection } from "./db/shared.js";
+import { ImmediateIssueSessionProjectionInvalidator } from "./issue-session-projection-invalidator.js";
 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";
 export class PatchRelayDatabase {
     connection;
+    telemetry = noopTelemetry;
+    telemetryProxy = {
+        emit: (event) => this.telemetry.emit(event),
+    };
     linearInstallations;
     operatorFeed;
     repositories;
@@ -23,8 +29,11 @@ export class PatchRelayDatabase {
     workflowWakes;
     runs;
     trackedIssues;
-    constructor(databasePath, wal) {
+    constructor(databasePath, wal, telemetry) {
         this.databasePath = databasePath;
+        if (telemetry) {
+            this.telemetry = telemetry;
+        }
         this.connection = new SqliteConnection(databasePath);
         this.connection.pragma("foreign_keys = ON");
         if (wal) {
@@ -34,20 +43,31 @@ export class PatchRelayDatabase {
         this.operatorFeed = new OperatorFeedStore(this.connection);
         this.repositories = new RepositoryLinkStore(this.connection);
         this.webhookEvents = new WebhookEventStore(this.connection);
-        this.issues = new IssueStore(this.connection, (issue) => syncIssueSessionFromIssue({ connection: this.connection, issues: this.issues, issueSessions: this.issueSessions, runs: this.runs, issue }));
-        this.runs = new RunStore(this.connection, mapRunRow, this.issues, (issue, options) => syncIssueSessionFromIssue({
-            connection: this.connection,
-            issues: this.issues,
-            issueSessions: this.issueSessions,
-            runs: this.runs,
-            issue,
-            ...(options ? { options } : {}),
-        }));
-        this.issueSessions = new IssueSessionStore(this.connection, mapIssueSessionRow, mapIssueSessionEventRow, this.issues, this.runs);
+        const issueSessionProjection = new ImmediateIssueSessionProjectionInvalidator({
+            getIssue: (projectId, linearIssueId) => this.issues.getIssue(projectId, linearIssueId),
+            listDependents: (projectId, blockerLinearIssueId) => this.issues.listDependents(projectId, blockerLinearIssueId),
+            countUnresolvedBlockers: (projectId, linearIssueId) => this.issues.countUnresolvedBlockers(projectId, linearIssueId),
+            getIssueSessionWaitingReason: (projectId, linearIssueId) => this.issueSessions.getIssueSession(projectId, linearIssueId)?.waitingReason,
+            projectIssue: (issue, options) => syncIssueSessionFromIssue({
+                connection: this.connection,
+                issues: this.issues,
+                issueSessions: this.issueSessions,
+                runs: this.runs,
+                issue,
+                ...(options ? { options } : {}),
+            }),
+            telemetry: this.telemetryProxy,
+        });
+        this.issues = new IssueStore(this.connection, issueSessionProjection);
+        this.runs = new RunStore(this.connection, mapRunRow, this.issues, issueSessionProjection, this.telemetryProxy);
+        this.issueSessions = new IssueSessionStore(this.connection, mapIssueSessionRow, mapIssueSessionEventRow, this.issues, this.runs, issueSessionProjection, this.telemetryProxy);
         this.workflowWakes = new WorkflowWakeResolver(this.issues, this.issueSessions);
         this.trackedIssues = new TrackedIssueQuery(this.issues, this.issueSessions, this.workflowWakes, this.runs);
     }
     databasePath;
+    setTelemetry(telemetry) {
+        this.telemetry = telemetry;
+    }
     runMigrations() {
         runPatchRelayMigrations(this.connection);
         this.assertSchemaReady();

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

@@ -1,17 +1,20 @@
 import { randomUUID } from "node:crypto";
 import { getThreadTurns } from "./codex-thread-utils.js";
+import { emitTelemetry, noopTelemetry } from "./telemetry.js";
 const ISSUE_SESSION_LEASE_MS = 10 * 60_000;
 export class IssueSessionLeaseService {
     db;
     logger;
     workerId;
     readThreadWithRetry;
+    telemetry;
     activeSessionLeases = new Map();
-    constructor(db, logger, workerId, readThreadWithRetry) {
+    constructor(db, logger, workerId, readThreadWithRetry, telemetry = noopTelemetry) {
         this.db = db;
         this.logger = logger;
         this.workerId = workerId;
         this.readThreadWithRetry = readThreadWithRetry;
+        this.telemetry = telemetry;
     }
     hasLocalLease(projectId, linearIssueId) {
         return this.getValidatedLocalLeaseId(projectId, linearIssueId) !== undefined;
@@ -38,9 +41,13 @@ export class IssueSessionLeaseService {
             workerId: this.workerId,
             leasedUntil,
         });
-        if (!acquired)
+        if (!acquired) {
+            this.emitLease("lease.acquire_failed", projectId, linearIssueId);
+            this.emitStaleLeaseInvariantIfRunnable(projectId, linearIssueId);
             return undefined;
+        }
         this.activeSessionLeases.set(this.issueSessionLeaseKey(projectId, linearIssueId), leaseId);
+        this.emitLease("lease.acquired", projectId, linearIssueId, leaseId);
         return leaseId;
     }
     forceAcquire(projectId, linearIssueId) {
@@ -53,9 +60,12 @@ export class IssueSessionLeaseService {
             workerId: this.workerId,
             leasedUntil,
         });
-        if (!acquired)
+        if (!acquired) {
+            this.emitLease("lease.acquire_failed", projectId, linearIssueId);
             return undefined;
+        }
         this.activeSessionLeases.set(this.issueSessionLeaseKey(projectId, linearIssueId), leaseId);
+        this.emitLease("lease.acquired", projectId, linearIssueId, leaseId);
         return leaseId;
     }
     claimForReconciliation(projectId, linearIssueId) {
@@ -68,8 +78,12 @@ export class IssueSessionLeaseService {
             return "skip";
         const leasedUntilMs = session.leasedUntil ? Date.parse(session.leasedUntil) : undefined;
         if (leasedUntilMs !== undefined && Number.isFinite(leasedUntilMs) && leasedUntilMs > Date.now()) {
+            this.emitStaleLeaseInvariantIfRunnable(projectId, linearIssueId);
             return "skip";
         }
+        if (session.leaseId) {
+            this.emitLease("lease.expired", projectId, linearIssueId, session.leaseId);
+        }
         return this.acquire(projectId, linearIssueId) ? true : "skip";
     }
     async reclaimForeignRecoveryLeaseIfSafe(run, issue) {
@@ -111,6 +125,16 @@ export class IssueSessionLeaseService {
             previousLeaseId: session.leaseId,
             reclaimedLeaseId: leaseId,
         }, "Reclaimed foreign issue-session lease for active-run recovery");
+        emitTelemetry(this.telemetry, {
+            type: "lease.reclaimed",
+            projectId: run.projectId,
+            linearIssueId: run.linearIssueId,
+            issueKey: issue.issueKey,
+            runId: run.id,
+            runType: run.runType,
+            leaseId,
+            workerId: this.workerId,
+        });
         return true;
     }
     heartbeat(projectId, linearIssueId) {
@@ -136,6 +160,7 @@ export class IssueSessionLeaseService {
         const leaseId = this.getValidatedLocalLeaseId(projectId, linearIssueId);
         this.db.issueSessions.releaseIssueSessionLease(projectId, linearIssueId, leaseId);
         this.activeSessionLeases.delete(key);
+        this.emitLease("lease.released", projectId, linearIssueId, leaseId);
     }
     getValidatedLocalLeaseId(projectId, linearIssueId) {
         const key = this.issueSessionLeaseKey(projectId, linearIssueId);
@@ -151,4 +176,33 @@ export class IssueSessionLeaseService {
     issueSessionLeaseKey(projectId, linearIssueId) {
         return `${projectId}:${linearIssueId}`;
     }
+    emitLease(type, projectId, linearIssueId, leaseId) {
+        const issue = this.db.issues.getIssue(projectId, linearIssueId);
+        emitTelemetry(this.telemetry, {
+            type,
+            projectId,
+            linearIssueId,
+            ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
+            ...(issue?.activeRunId ? { runId: issue.activeRunId } : {}),
+            ...(leaseId ? { leaseId } : {}),
+            workerId: this.workerId,
+        });
+    }
+    emitStaleLeaseInvariantIfRunnable(projectId, linearIssueId) {
+        const issue = this.db.issues.getIssue(projectId, linearIssueId);
+        const wake = this.db.workflowWakes.peekIssueWake(projectId, linearIssueId);
+        const runType = wake?.runType ?? issue?.pendingRunType;
+        if (!runType)
+            return;
+        emitTelemetry(this.telemetry, {
+            type: "health.invariant",
+            invariant: "stale_lease_blocking_runnable_work",
+            status: "observed",
+            projectId,
+            linearIssueId,
+            ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
+            runType,
+            detail: "Runnable work could not acquire an issue-session lease",
+        });
+    }
 }

package/dist/issue-session-projection-invalidator.js

@@ -0,0 +1,90 @@
+import { emitTelemetry, noopTelemetry } from "./telemetry.js";
+export class ImmediateIssueSessionProjectionInvalidator {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    issueChanged(issue, options) {
+        const dependents = this.deps.listDependents(issue.projectId, issue.linearIssueId);
+        this.emitInvalidated("issue_changed", issue.projectId, issue.linearIssueId, issue.issueKey, 1 + dependents.length);
+        this.projectIssue(issue, "issue_changed", options);
+        for (const dependent of dependents) {
+            this.projectIssueById(dependent.projectId, dependent.linearIssueId, "issue_changed");
+        }
+    }
+    issueRunChanged(issue, options) {
+        this.emitInvalidated("issue_run_changed", issue.projectId, issue.linearIssueId, issue.issueKey, 1);
+        this.projectIssue(issue, "issue_run_changed", options);
+    }
+    issueDependenciesChanged(projectId, linearIssueId) {
+        this.emitInvalidated("issue_dependencies_changed", projectId, linearIssueId, undefined, 1);
+        this.projectIssueById(projectId, linearIssueId, "issue_dependencies_changed");
+    }
+    dependencyBlockerChanged(projectId, blockerLinearIssueId) {
+        const dependents = this.deps.listDependents(projectId, blockerLinearIssueId);
+        this.emitInvalidated("dependency_blocker_changed", projectId, blockerLinearIssueId, undefined, dependents.length);
+        for (const dependent of dependents) {
+            this.projectIssueById(dependent.projectId, dependent.linearIssueId, "dependency_blocker_changed");
+        }
+    }
+    issueSessionEventsChanged(projectId, linearIssueId) {
+        this.emitInvalidated("issue_session_events_changed", projectId, linearIssueId, undefined, 1);
+        this.projectIssueById(projectId, linearIssueId, "issue_session_events_changed");
+    }
+    projectIssueById(projectId, linearIssueId, reason) {
+        const issue = this.deps.getIssue(projectId, linearIssueId);
+        if (issue) {
+            this.projectIssue(issue, reason);
+        }
+    }
+    projectIssue(issue, reason, options) {
+        const beforeWaitingReason = this.deps.getIssueSessionWaitingReason?.(issue.projectId, issue.linearIssueId);
+        this.deps.projectIssue(issue, options);
+        this.emitReprojected(reason, issue);
+        const unresolved = this.deps.countUnresolvedBlockers?.(issue.projectId, issue.linearIssueId);
+        const afterWaitingReason = this.deps.getIssueSessionWaitingReason?.(issue.projectId, issue.linearIssueId);
+        if (unresolved === 0
+            && beforeWaitingReason?.startsWith("Blocked by ")
+            && !afterWaitingReason?.startsWith("Blocked by ")) {
+            emitTelemetry(this.deps.telemetry ?? noopTelemetry, {
+                type: "health.invariant",
+                invariant: "stale_blocked_read_model",
+                status: "repaired",
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                detail: "Projection cleared stale blocked waiting reason after blockers resolved",
+            });
+        }
+        else if (unresolved === 0 && afterWaitingReason?.startsWith("Blocked by ")) {
+            emitTelemetry(this.deps.telemetry ?? noopTelemetry, {
+                type: "health.invariant",
+                invariant: "stale_blocked_read_model",
+                status: "observed",
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                detail: "Issue session still reports blocked after source blockers resolved",
+            });
+        }
+    }
+    emitInvalidated(reason, projectId, linearIssueId, issueKey, affectedCount) {
+        emitTelemetry(this.deps.telemetry ?? noopTelemetry, {
+            type: "projection.invalidated",
+            reason,
+            projectId,
+            linearIssueId,
+            ...(issueKey ? { issueKey } : {}),
+            affectedCount,
+        });
+    }
+    emitReprojected(reason, issue) {
+        emitTelemetry(this.deps.telemetry ?? noopTelemetry, {
+            type: "projection.reprojected",
+            reason,
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+        });
+    }
+}

package/dist/run-orchestrator.js

@@ -23,6 +23,7 @@ import { classifyIssue } from "./issue-class.js";
 import { buildIssueTriageHash, IssueTriageService } from "./issue-triage.js";
 import { loadConfig } from "./config.js";
 import { CodexThreadMaterializingError, isThreadMaterializingError } from "./codex-thread-errors.js";
+import { emitTelemetry, noopTelemetry } from "./telemetry.js";
 function lowerCaseFirst(value) {
     return value ? `${value.slice(0, 1).toLowerCase()}${value.slice(1)}` : value;
 }
@@ -84,7 +85,8 @@ export class RunOrchestrator {
     logger;
     feed;
     configPath;
-    constructor(config, db, codex, linearProvider, enqueueIssue, wakeDispatcherOrLogger, loggerOrFeed, feedOrConfigPath, configPathOrUndefined) {
+    telemetry;
+    constructor(config, db, codex, linearProvider, enqueueIssue, wakeDispatcherOrLogger, loggerOrFeed, feedOrConfigPath, configPathOrUndefined, telemetryOrUndefined) {
         this.config = config;
         this.db = db;
         this.codex = codex;
@@ -95,6 +97,7 @@ export class RunOrchestrator {
         let logger;
         let feed;
         let configPath;
+        const telemetry = telemetryOrUndefined ?? noopTelemetry;
         if (wakeDispatcherOrLogger instanceof WakeDispatcher) {
             this.wakeDispatcher = wakeDispatcherOrLogger;
             logger = loggerOrFeed;
@@ -109,15 +112,16 @@ export class RunOrchestrator {
             // gets wired below once the lease service exists. The stub is
             // never called before the wiring completes because the run()
             // loop is the only consumer of releaseRunAndDispatch.
-            this.wakeDispatcher = new WakeDispatcher(db, enqueueIssue, (projectId, linearIssueId) => this.leaseService?.release(projectId, linearIssueId), logger, feed);
+            this.wakeDispatcher = new WakeDispatcher(db, enqueueIssue, (projectId, linearIssueId) => this.leaseService?.release(projectId, linearIssueId), logger, feed, telemetry);
         }
         this.logger = logger;
         this.feed = feed;
         this.configPath = configPath;
+        this.telemetry = telemetry;
         this.worktreeManager = new WorktreeManager(config);
         this.codexRuntimeConfig = config.runner.codex;
         this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
-        this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, this.threadPorts.readThreadWithRetry);
+        this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, this.threadPorts.readThreadWithRetry, telemetry);
         this.activeSessionLeases = this.leaseService.activeSessionLeases;
         this.runCompletionPolicy = new RunCompletionPolicy(config, db, logger, this.leasePorts.withHeldLease);
         this.completionCheck = new CompletionCheckService(codex, logger);
@@ -237,9 +241,20 @@ export class RunOrchestrator {
     }
     // ─── Run ────────────────────────────────────────────────────────
     async run(item) {
+        emitTelemetry(this.telemetry, {
+            type: "queue.dequeued",
+            projectId: item.projectId,
+            linearIssueId: item.issueId,
+        });
+        emitTelemetry(this.telemetry, {
+            type: "run.dequeued",
+            projectId: item.projectId,
+            linearIssueId: item.issueId,
+        });
         await this.refreshCodexRuntimeConfig();
         const project = this.config.projects.find((p) => p.id === item.projectId);
         if (!project) {
+            this.emitRunSkipped(item, "project_not_configured");
             this.logger.info({ projectId: item.projectId, linearIssueId: item.issueId, reason: "project_not_configured" }, "Skipped issue run: project missing from config");
             return;
         }
@@ -248,30 +263,38 @@ export class RunOrchestrator {
         // pending wake didn't actually run. The original incident
         // (LSR-495) was undiagnosable because these guards were silent.
         if (this.leaseService.hasLocalLease(item.projectId, item.issueId)) {
+            this.emitRunSkipped(item, "lease_held_locally");
             this.logger.info({ projectId: item.projectId, linearIssueId: item.issueId, reason: "lease_held_locally" }, "Skipped issue run: another in-process call still holds the lease");
             return;
         }
         const initialIssue = this.db.issues.getIssue(item.projectId, item.issueId);
         if (!initialIssue) {
+            this.emitRunSkipped(item, "issue_missing");
             this.logger.info({ projectId: item.projectId, linearIssueId: item.issueId, reason: "issue_missing" }, "Skipped issue run: issue row not found");
             return;
         }
         if (initialIssue.activeRunId !== undefined) {
+            this.emitActiveRunBlockerInvariant(initialIssue);
+            this.emitRunSkipped(item, "active_run_present", initialIssue, { activeRunId: initialIssue.activeRunId });
             this.logger.info({ issueKey: initialIssue.issueKey, projectId: item.projectId, reason: "active_run_present", activeRunId: initialIssue.activeRunId }, "Skipped issue run: an active run is already in flight");
             return;
         }
         const issue = await this.classifyTrackedIssue(initialIssue);
         if (!issue) {
+            this.emitRunSkipped(item, "classification_dropped_issue");
             this.logger.info({ projectId: item.projectId, linearIssueId: item.issueId, reason: "classification_dropped_issue" }, "Skipped issue run: classification returned no issue");
             return;
         }
         if (issue.activeRunId !== undefined) {
+            this.emitActiveRunBlockerInvariant(issue);
+            this.emitRunSkipped(item, "active_run_present_post_classify", issue, { activeRunId: issue.activeRunId });
             this.logger.info({ issueKey: issue.issueKey, projectId: item.projectId, reason: "active_run_present_post_classify", activeRunId: issue.activeRunId }, "Skipped issue run: an active run appeared during classification");
             return;
         }
         const issueSession = this.db.issueSessions.getIssueSession(item.projectId, item.issueId);
         const leaseId = this.leaseService.acquire(item.projectId, item.issueId);
         if (!leaseId) {
+            this.emitRunSkipped(item, "lease_acquire_failed", issue);
             this.logger.info({ issueKey: issue.issueKey, projectId: item.projectId, reason: "lease_acquire_failed" }, "Skipped issue run: another worker holds the session lease");
             return;
         }
@@ -283,19 +306,23 @@ export class RunOrchestrator {
         const wakeIssue = this.materializeLegacyPendingWake(issue, { projectId: item.projectId, linearIssueId: item.issueId, leaseId });
         const wake = this.resolveRunWake(wakeIssue);
         if (!wake) {
+            this.emitRunSkipped(item, "no_wake_derivable", issue);
             this.logger.info({ issueKey: issue.issueKey, projectId: item.projectId, reason: "no_wake_derivable" }, "Skipped issue run: no actionable wake derivable from pending events");
             this.leaseService.release(item.projectId, item.issueId);
             return;
         }
         const { runType, context, resumeThread } = wake;
         if (runType === "implementation" && this.db.issues.countUnresolvedBlockers(item.projectId, item.issueId) > 0) {
+            const blockerCount = this.db.issues.countUnresolvedBlockers(item.projectId, item.issueId);
             this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(item.projectId, item.issueId);
             this.releaseIssueSessionLease(item.projectId, item.issueId);
+            this.emitRunSkipped(item, "blocked", issue, { runType, blockerCount });
             this.logger.info({ issueKey: issue.issueKey }, "Skipped implementation launch because the issue is blocked");
             return;
         }
         const remainingZombieDelayMs = shouldDelayZombieRecoveryLaunch(issue, issueSession, runType);
         if (remainingZombieDelayMs > 0) {
+            this.emitRunSkipped(item, "zombie_backoff", issue, { runType, remainingDelayMs: remainingZombieDelayMs });
             this.logger.debug({ issueKey: issue.issueKey, runType, remainingZombieDelayMs }, "Deferring recovered run launch until zombie backoff elapses");
             this.releaseIssueSessionLease(item.projectId, item.issueId);
             return;
@@ -314,6 +341,7 @@ export class RunOrchestrator {
             const dismissed = this.db.issueSessions.dismissIssueSessionEventsWithLease(lease, requestedChangesEventIds);
             if (!dismissed) {
                 this.releaseIssueSessionLease(item.projectId, item.issueId);
+                this.emitRunSkipped(item, "lease_lost_dismissing_inactive_requested_changes_wake", issue, { runType });
                 this.logger.info({ issueKey: issue.issueKey, projectId: item.projectId, reason: "lease_lost_dismissing_inactive_requested_changes_wake" }, "Skipped issue run: lost lease while dismissing inactive requested-changes wake");
                 return;
             }
@@ -335,6 +363,7 @@ export class RunOrchestrator {
                 prReviewState: launchIssue.prReviewState,
                 prState: launchIssue.prState,
             }, "Skipped issue run: requested-changes wake is no longer active");
+            this.emitRunSkipped(item, "inactive_requested_changes_wake", issue, { runType });
             this.releaseIssueSessionLease(item.projectId, item.issueId);
             this.wakeDispatcher.dispatchIfWakePending(item.projectId, item.issueId);
             return;
@@ -363,10 +392,12 @@ export class RunOrchestrator {
                 : issue.prHeadSha;
         const budgetExceeded = this.runWakePlanner.budgetExceeded(issue, project, runType, isRequestedChangesRunType);
         if (budgetExceeded) {
+            this.emitRunSkipped(item, "budget_exceeded", issue, { runType });
             this.escalate(issue, runType, budgetExceeded);
             return;
         }
         if (!this.runWakePlanner.incrementAttemptCounters(issue, { projectId: issue.projectId, linearIssueId: issue.linearIssueId, leaseId }, runType, isRequestedChangesRunType)) {
+            this.emitRunSkipped(item, "lease_lost_incrementing_attempts", issue, { runType });
             this.releaseIssueSessionLease(item.projectId, item.issueId);
             return;
         }
@@ -390,6 +421,7 @@ export class RunOrchestrator {
             worktreePath,
         });
         if (!run) {
+            this.emitRunSkipped(item, "claim_failed", issue, { runType });
             this.releaseIssueSessionLease(item.projectId, item.issueId);
             return;
         }
@@ -453,6 +485,37 @@ export class RunOrchestrator {
     async resetWorktreeToTrackedBranch(worktreePath, branchName, issue) {
         await this.worktreeManager.resetWorktreeToTrackedBranch(worktreePath, branchName, issue, this.logger);
     }
+    emitRunSkipped(item, reason, issue, details) {
+        emitTelemetry(this.telemetry, {
+            type: "run.skipped",
+            projectId: item.projectId,
+            linearIssueId: item.issueId,
+            ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
+            reason,
+            ...(details?.runType ? { runType: details.runType } : {}),
+            ...(details?.activeRunId !== undefined ? { activeRunId: details.activeRunId } : {}),
+            ...(details?.blockerCount !== undefined ? { blockerCount: details.blockerCount } : {}),
+            ...(details?.remainingDelayMs !== undefined ? { remainingDelayMs: details.remainingDelayMs } : {}),
+        });
+    }
+    emitActiveRunBlockerInvariant(issue) {
+        if (issue.activeRunId === undefined)
+            return;
+        const blockerCount = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
+        if (blockerCount === 0)
+            return;
+        emitTelemetry(this.telemetry, {
+            type: "health.invariant",
+            invariant: "active_run_with_unresolved_blocker",
+            status: "observed",
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+            runId: issue.activeRunId,
+            blockerCount,
+            detail: "Run dequeue found an active run while blockers are unresolved",
+        });
+    }
     async restoreIdleWorktree(issue) {
         await this.worktreeManager.restoreIdleWorktree(issue, this.logger);
     }

package/dist/service.js

@@ -17,6 +17,7 @@ import { acceptIncomingWebhook } from "./service-webhooks.js";
 import { parseStringArray, TrackedIssueListQuery } from "./tracked-issue-list-query.js";
 import { AgentInputService } from "./agent-input-service.js";
 import { CodexFollowupIntentClassifier } from "./followup-intent.js";
+import { FanoutPatchRelayTelemetry, LoggerTelemetrySink, OperatorFeedTelemetrySink } from "./telemetry.js";
 export class PatchRelayService {
     config;
     db;
@@ -43,6 +44,11 @@ export class PatchRelayService {
         this.configPath = configPath;
         this.linearProvider = toLinearClientProvider(linearProvider);
         this.feed = new OperatorEventFeed(db.operatorFeed);
+        const telemetry = new FanoutPatchRelayTelemetry([
+            new LoggerTelemetrySink(logger),
+            new OperatorFeedTelemetrySink(this.feed),
+        ]);
+        db.setTelemetry(telemetry);
         let enqueueIssue = () => {
             throw new Error("Service runtime enqueueIssue is not initialized");
         };
@@ -55,11 +61,11 @@ export class PatchRelayService {
         // runtime owns the queue, and the lease service lives inside the
         // orchestrator (its construction depends on the Codex client). All
         // downstream consumers receive this single dispatcher instance.
-        const dispatcher = new WakeDispatcher(db, (projectId, issueId) => enqueueIssue(projectId, issueId), (projectId, issueId) => leaseRelease(projectId, issueId), logger, this.feed);
+        const dispatcher = new WakeDispatcher(db, (projectId, issueId) => enqueueIssue(projectId, issueId), (projectId, issueId) => leaseRelease(projectId, issueId), logger, this.feed, telemetry);
         const agentInput = new AgentInputService(db, codex, dispatcher, logger, this.feed, new CodexFollowupIntentClassifier(codex, logger));
-        this.orchestrator = new RunOrchestrator(config, db, codex, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), dispatcher, logger, this.feed, this.configPath);
+        this.orchestrator = new RunOrchestrator(config, db, codex, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), dispatcher, logger, this.feed, this.configPath, telemetry);
         leaseRelease = (projectId, issueId) => this.orchestrator.leaseService.release(projectId, issueId);
-        this.webhookHandler = new WebhookHandler(config, db, this.linearProvider, codex, dispatcher, logger, this.feed, undefined, agentInput);
+        this.webhookHandler = new WebhookHandler(config, db, this.linearProvider, codex, dispatcher, logger, this.feed, undefined, agentInput, telemetry);
         this.githubWebhookHandler = new GitHubWebhookHandler(config, db, this.linearProvider, dispatcher, logger, codex, this.feed);
         const runtime = new ServiceRuntime(codex, logger, this.orchestrator, { listIssuesReadyForExecution: () => db.listIssuesReadyForExecution() }, this.webhookHandler, {
             processIssue: async (item) => {

package/dist/telemetry.js

@@ -0,0 +1,85 @@
+export const noopTelemetry = {
+    emit: () => undefined,
+};
+export function emitTelemetry(telemetry, event) {
+    try {
+        telemetry.emit(event);
+    }
+    catch {
+        // Telemetry must never affect workflow execution.
+    }
+}
+export class FanoutPatchRelayTelemetry {
+    sinks;
+    constructor(sinks) {
+        this.sinks = sinks;
+    }
+    emit(event) {
+        for (const sink of this.sinks) {
+            emitTelemetry(sink, event);
+        }
+    }
+}
+export class MemoryPatchRelayTelemetry {
+    events = [];
+    emit(event) {
+        this.events.push(event);
+    }
+    list(type) {
+        if (!type)
+            return this.events;
+        return this.events.filter((event) => event.type === type);
+    }
+}
+export class LoggerTelemetrySink {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    emit(event) {
+        this.logger.info({ telemetryEvent: event.type, ...event }, "PatchRelay telemetry event");
+    }
+}
+export class OperatorFeedTelemetrySink {
+    feed;
+    constructor(feed) {
+        this.feed = feed;
+    }
+    emit(event) {
+        const feedEvent = this.toFeedEvent(event);
+        if (feedEvent) {
+            this.feed.publish(feedEvent);
+        }
+    }
+    toFeedEvent(event) {
+        switch (event.type) {
+            case "dependency.dependent_unblocked":
+                return {
+                    level: "info",
+                    kind: "workflow",
+                    ...(event.issueKey ? { issueKey: event.issueKey } : {}),
+                    ...(event.projectId ? { projectId: event.projectId } : {}),
+                    ...(event.dispatchedRunType ? { stage: event.dispatchedRunType } : {}),
+                    status: "dependency_unblocked",
+                    summary: event.dispatchedRunType
+                        ? `Dependency unblocked; ${event.dispatchedRunType} queued`
+                        : "Dependency unblocked",
+                };
+            case "run.skipped":
+                if (event.reason === "blocked" || event.reason === "lease_acquire_failed" || event.reason === "no_wake_derivable") {
+                    return {
+                        level: event.reason === "blocked" ? "info" : "warn",
+                        kind: "stage",
+                        ...(event.issueKey ? { issueKey: event.issueKey } : {}),
+                        ...(event.projectId ? { projectId: event.projectId } : {}),
+                        ...(event.runType ? { stage: event.runType } : {}),
+                        status: "skipped",
+                        summary: `Run skipped: ${event.reason}`,
+                    };
+                }
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
+}

package/dist/wake-dispatcher.js

@@ -1,3 +1,4 @@
+import { emitTelemetry, noopTelemetry } from "./telemetry.js";
 // Single owner of "append a session event and tell the orchestrator
 // something might be runnable", and of "release a finished run so the
 // next wake fires." Until this existed, 8+ call sites each made their
@@ -21,13 +22,15 @@ export class WakeDispatcher {
     releaseLease;
     logger;
     feed;
+    telemetry;
     currentTick;
-    constructor(db, enqueueIssue, releaseLease, logger, feed) {
+    constructor(db, enqueueIssue, releaseLease, logger, feed, telemetry = noopTelemetry) {
         this.db = db;
         this.enqueueIssue = enqueueIssue;
         this.releaseLease = releaseLease;
         this.logger = logger;
         this.feed = feed;
+        this.telemetry = telemetry;
     }
     // Scope the next enqueue calls inside `fn` to a single dedupe Set.
     // Nested ticks reuse the outermost Set so deeply nested helpers do
@@ -48,11 +51,23 @@ export class WakeDispatcher {
     // would have, or undefined if the event is non-actionable / no wake
     // exists / a run is already running (the finalizer will drain it).
     recordEventAndDispatch(projectId, linearIssueId, event, options) {
-        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(projectId, linearIssueId, {
+        const appended = this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(projectId, linearIssueId, {
             projectId,
             linearIssueId,
             ...event,
         });
+        const issue = this.db.issues.getIssue(projectId, linearIssueId);
+        if (appended) {
+            emitTelemetry(this.telemetry, {
+                type: "wake.created",
+                projectId,
+                linearIssueId,
+                ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
+                eventIds: [appended.id],
+                sessionEventType: event.eventType,
+                ...(event.dedupeKey ? { dedupeKey: event.dedupeKey } : {}),
+            });
+        }
         // Honour the active tick scope (set via withTick) so callers nested
         // inside a reconcile pass automatically dedupe without threading
         // the Set through every helper signature.
@@ -67,22 +82,143 @@ export class WakeDispatcher {
     // post-run drain via releaseRunAndDispatch.
     dispatchIfWakePending(projectId, linearIssueId, options) {
         const issue = this.db.issues.getIssue(projectId, linearIssueId);
-        if (issue?.activeRunId !== undefined)
+        if (!issue) {
+            emitTelemetry(this.telemetry, {
+                type: "wake.suppressed",
+                projectId,
+                linearIssueId,
+                reason: "issue_missing",
+            });
+            return undefined;
+        }
+        if (issue.activeRunId !== undefined) {
+            const blockerCount = this.db.issues.countUnresolvedBlockers(projectId, linearIssueId);
+            emitTelemetry(this.telemetry, {
+                type: "wake.suppressed",
+                projectId,
+                linearIssueId,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                reason: "active_run_present",
+                activeRunId: issue.activeRunId,
+                ...(blockerCount > 0 ? { blockerCount } : {}),
+            });
+            if (blockerCount > 0) {
+                emitTelemetry(this.telemetry, {
+                    type: "health.invariant",
+                    invariant: "active_run_with_unresolved_blocker",
+                    status: "observed",
+                    projectId,
+                    linearIssueId,
+                    ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                    runId: issue.activeRunId,
+                    blockerCount,
+                    detail: "Wake suppressed because an active run exists while blockers are unresolved",
+                });
+            }
+            return undefined;
+        }
+        const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(projectId, linearIssueId);
+        if (unresolvedBlockers > 0) {
+            const blockerKeys = this.unresolvedBlockerKeys(projectId, linearIssueId);
+            emitTelemetry(this.telemetry, {
+                type: "wake.suppressed",
+                projectId,
+                linearIssueId,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                reason: "blocked",
+                blockerCount: unresolvedBlockers,
+                blockerKeys,
+            });
+            const pendingBlockedWake = this.db.issueSessions.peekIssueSessionWake(projectId, linearIssueId) ?? issue.pendingRunType;
+            if (pendingBlockedWake) {
+                emitTelemetry(this.telemetry, {
+                    type: "health.invariant",
+                    invariant: "blocked_issue_with_pending_wake",
+                    status: "observed",
+                    projectId,
+                    linearIssueId,
+                    ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                    blockerCount: unresolvedBlockers,
+                    detail: "Wake remains pending while blockers are unresolved",
+                });
+            }
             return undefined;
+        }
         const wake = this.db.workflowWakes.peekIssueWake(projectId, linearIssueId);
         // Fall back to the legacy pending_run_type column. The orchestrator
         // materializes it into a real event at run time, but the poke still
         // needs to happen now so the orchestrator gets called at all.
-        const runType = wake?.runType ?? issue?.pendingRunType;
-        if (!runType)
+        const runType = wake?.runType ?? issue.pendingRunType;
+        if (!runType) {
+            emitTelemetry(this.telemetry, {
+                type: "wake.suppressed",
+                projectId,
+                linearIssueId,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                reason: "no_wake_derivable",
+            });
+            if (this.db.listIssuesReadyForExecution().some((entry) => entry.projectId === projectId && entry.linearIssueId === linearIssueId)) {
+                emitTelemetry(this.telemetry, {
+                    type: "health.invariant",
+                    invariant: "ready_issue_not_enqueued",
+                    status: "observed",
+                    projectId,
+                    linearIssueId,
+                    ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                    detail: "Issue appears ready for execution but no wake was derivable for enqueue",
+                });
+            }
             return undefined;
+        }
+        emitTelemetry(this.telemetry, {
+            type: "wake.derived",
+            projectId,
+            linearIssueId,
+            ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+            runType,
+            ...(wake?.wakeReason ? { wakeReason: wake.wakeReason } : {}),
+            ...(wake?.eventIds ? { eventIds: wake.eventIds } : {}),
+            source: wake ? (wake.eventIds.length > 0 ? "session_event" : "implicit") : "legacy_pending_run_type",
+        });
         const tick = options?.enqueuedThisTick ?? this.currentTick;
         const key = `${projectId}:${linearIssueId}`;
         if (tick?.has(key)) {
+            emitTelemetry(this.telemetry, {
+                type: "wake.deduped",
+                projectId,
+                linearIssueId,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                runType,
+                ...(wake?.wakeReason ? { wakeReason: wake.wakeReason } : {}),
+                ...(wake?.eventIds ? { eventIds: wake.eventIds } : {}),
+            });
+            emitTelemetry(this.telemetry, {
+                type: "queue.deduped",
+                projectId,
+                linearIssueId,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                runType,
+            });
             return runType;
         }
         tick?.add(key);
         this.enqueueIssue(projectId, linearIssueId);
+        emitTelemetry(this.telemetry, {
+            type: "wake.dispatched",
+            projectId,
+            linearIssueId,
+            ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+            runType,
+            ...(wake?.wakeReason ? { wakeReason: wake.wakeReason } : {}),
+            ...(wake?.eventIds ? { eventIds: wake.eventIds } : {}),
+        });
+        emitTelemetry(this.telemetry, {
+            type: "queue.enqueued",
+            projectId,
+            linearIssueId,
+            ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+            runType,
+        });
         return runType;
     }
     // Release the lease for a finished run, then drain any wake that
@@ -97,10 +233,42 @@ export class WakeDispatcher {
     // check paths publish their own more-specific event and pass false.
     releaseRunAndDispatch(params) {
         this.releaseLease(params.run.projectId, params.run.linearIssueId);
+        emitTelemetry(this.telemetry, {
+            type: "run.released",
+            projectId: params.run.projectId,
+            linearIssueId: params.run.linearIssueId,
+            ...(params.issueKey ? { issueKey: params.issueKey } : {}),
+            runId: params.run.id,
+            runType: params.run.runType,
+        });
         const wake = this.db.workflowWakes.peekIssueWake(params.run.projectId, params.run.linearIssueId);
-        if (!wake)
+        if (!wake) {
+            emitTelemetry(this.telemetry, {
+                type: "wake.suppressed",
+                projectId: params.run.projectId,
+                linearIssueId: params.run.linearIssueId,
+                ...(params.issueKey ? { issueKey: params.issueKey } : {}),
+                reason: "no_wake_derivable",
+            });
             return undefined;
+        }
         this.enqueueIssue(params.run.projectId, params.run.linearIssueId);
+        emitTelemetry(this.telemetry, {
+            type: "wake.dispatched",
+            projectId: params.run.projectId,
+            linearIssueId: params.run.linearIssueId,
+            ...(params.issueKey ? { issueKey: params.issueKey } : {}),
+            runType: wake.runType,
+            ...(wake.wakeReason ? { wakeReason: wake.wakeReason } : {}),
+            eventIds: wake.eventIds,
+        });
+        emitTelemetry(this.telemetry, {
+            type: "queue.enqueued",
+            projectId: params.run.projectId,
+            linearIssueId: params.run.linearIssueId,
+            ...(params.issueKey ? { issueKey: params.issueKey } : {}),
+            runType: wake.runType,
+        });
         if (params.publishDeferredFollowUp) {
             this.feed?.publish({
                 level: "info",
@@ -118,4 +286,10 @@ export class WakeDispatcher {
             ...(wake.wakeReason ? { wakeReason: wake.wakeReason } : {}),
         };
     }
+    unresolvedBlockerKeys(projectId, linearIssueId) {
+        return this.db.issues.listIssueDependencies(projectId, linearIssueId)
+            .filter((entry) => entry.blockerCurrentLinearStateType !== "completed"
+            && entry.blockerCurrentLinearState?.trim().toLowerCase() !== "done")
+            .map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId);
+    }
 }

package/dist/webhook-handler.js

@@ -14,6 +14,7 @@ import { extractLatestAssistantSummary } from "./issue-session-events.js";
 import { WakeDispatcher } from "./wake-dispatcher.js";
 import { CodexFollowupIntentClassifier } from "./followup-intent.js";
 import { AgentInputService } from "./agent-input-service.js";
+import { noopTelemetry } from "./telemetry.js";
 export class WebhookHandler {
     config;
     db;
@@ -21,6 +22,7 @@ export class WebhookHandler {
     codex;
     logger;
     feed;
+    telemetry;
     installationHandler;
     issueRemovalHandler;
     commentWakeHandler;
@@ -30,20 +32,21 @@ export class WebhookHandler {
     dependencyReadinessHandler;
     linearSync;
     wakeDispatcher;
-    constructor(config, db, linearProvider, codex, wakeDispatcherOrEnqueueIssue, logger, feed, followupClassifier, agentInput) {
+    constructor(config, db, linearProvider, codex, wakeDispatcherOrEnqueueIssue, logger, feed, followupClassifier, agentInput, telemetry = noopTelemetry) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
         this.codex = codex;
         this.logger = logger;
         this.feed = feed;
+        this.telemetry = telemetry;
         // Webhook handlers never release leases — the orchestrator's
         // run finalizer owns that. So when a test passes a bare
         // enqueueIssue callback, wrap it in a dispatcher with a no-op
         // releaseLease (any production caller passes a real dispatcher).
         this.wakeDispatcher = wakeDispatcherOrEnqueueIssue instanceof WakeDispatcher
             ? wakeDispatcherOrEnqueueIssue
-            : new WakeDispatcher(db, wakeDispatcherOrEnqueueIssue, () => undefined, logger, feed);
+            : new WakeDispatcher(db, wakeDispatcherOrEnqueueIssue, () => undefined, logger, feed, telemetry);
         this.installationHandler = new InstallationWebhookHandler(config, { linearInstallations: db.linearInstallations }, logger, feed);
         this.issueRemovalHandler = new IssueRemovalHandler(db, feed);
         this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
@@ -53,7 +56,7 @@ export class WebhookHandler {
         this.agentSessionHandler = new AgentSessionHandler(config, db, linearProvider, codex, this.wakeDispatcher, logger, feed, agentInputService);
         this.desiredStageRecorder = new DesiredStageRecorder(db, linearProvider, this.wakeDispatcher, feed);
         this.contextLoader = new WebhookContextLoader(config, linearProvider);
-        this.dependencyReadinessHandler = new DependencyReadinessHandler(db, this.wakeDispatcher, (projectId, issueId) => this.peekPendingSessionWakeRunType(projectId, issueId));
+        this.dependencyReadinessHandler = new DependencyReadinessHandler(db, this.wakeDispatcher, (projectId, issueId) => this.peekPendingSessionWakeRunType(projectId, issueId), telemetry);
     }
     async processWebhookEvent(webhookEventId) {
         const event = this.db.webhookEvents.getWebhookPayload(webhookEventId);

package/dist/webhooks/dependency-readiness-handler.js

@@ -1,11 +1,14 @@
+import { emitTelemetry, noopTelemetry } from "../telemetry.js";
 export class DependencyReadinessHandler {
     db;
     wakeDispatcher;
     peekPendingSessionWakeRunType;
-    constructor(db, wakeDispatcher, peekPendingSessionWakeRunType) {
+    telemetry;
+    constructor(db, wakeDispatcher, peekPendingSessionWakeRunType, telemetry = noopTelemetry) {
         this.db = db;
         this.wakeDispatcher = wakeDispatcher;
         this.peekPendingSessionWakeRunType = peekPendingSessionWakeRunType;
+        this.telemetry = telemetry;
     }
     reconcile(projectId, blockerLinearIssueId) {
         const newlyReady = [];
@@ -16,6 +19,25 @@ export class DependencyReadinessHandler {
             }
             const unresolved = this.db.issues.countUnresolvedBlockers(projectId, dependent.linearIssueId);
             if (unresolved > 0) {
+                const blockerKeys = this.unresolvedBlockerKeys(projectId, dependent.linearIssueId);
+                emitTelemetry(this.telemetry, {
+                    type: "dependency.remaining_blockers",
+                    projectId,
+                    linearIssueId: dependent.linearIssueId,
+                    ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                    blockerLinearIssueId,
+                    blockerCount: unresolved,
+                    blockerKeys,
+                });
+                emitTelemetry(this.telemetry, {
+                    type: "dependency.dependent_blocked",
+                    projectId,
+                    linearIssueId: dependent.linearIssueId,
+                    ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                    blockerLinearIssueId,
+                    blockerCount: unresolved,
+                    blockerKeys,
+                });
                 if (this.peekPendingSessionWakeRunType(projectId, dependent.linearIssueId) === "implementation"
                     && issue.activeRunId === undefined
                     && !this.db.issueSessions.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
@@ -28,10 +50,25 @@ export class DependencyReadinessHandler {
                 }
                 continue;
             }
-            if (issue.factoryState !== "delegated"
-                || !issue.delegatedToPatchRelay
-                || issue.activeRunId !== undefined
-                || this.db.issueSessions.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
+            if (!issue.delegatedToPatchRelay || issue.activeRunId !== undefined) {
+                continue;
+            }
+            const pendingWakeRunType = this.db.workflowWakes.peekIssueWake(projectId, dependent.linearIssueId)?.runType
+                ?? issue.pendingRunType;
+            if (pendingWakeRunType) {
+                const dispatchedRunType = this.wakeDispatcher.dispatchIfWakePending(projectId, dependent.linearIssueId);
+                emitTelemetry(this.telemetry, {
+                    type: "dependency.dependent_unblocked",
+                    projectId,
+                    linearIssueId: dependent.linearIssueId,
+                    ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                    blockerLinearIssueId,
+                    ...(dispatchedRunType ? { dispatchedRunType } : {}),
+                });
+                newlyReady.push(dependent.linearIssueId);
+                continue;
+            }
+            if (issue.factoryState !== "delegated" || this.db.issueSessions.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
                 continue;
             }
             if (this.peekPendingSessionWakeRunType(projectId, dependent.linearIssueId) === "implementation") {
@@ -42,12 +79,26 @@ export class DependencyReadinessHandler {
                     pendingRunContextJson: null,
                 });
             }
-            this.wakeDispatcher.recordEventAndDispatch(projectId, dependent.linearIssueId, {
+            const dispatchedRunType = this.wakeDispatcher.recordEventAndDispatch(projectId, dependent.linearIssueId, {
                 eventType: "delegated",
                 dedupeKey: `delegated:${dependent.linearIssueId}`,
             });
+            emitTelemetry(this.telemetry, {
+                type: "dependency.dependent_unblocked",
+                projectId,
+                linearIssueId: dependent.linearIssueId,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                blockerLinearIssueId,
+                ...(dispatchedRunType ? { dispatchedRunType } : {}),
+            });
             newlyReady.push(dependent.linearIssueId);
         }
         return newlyReady;
     }
+    unresolvedBlockerKeys(projectId, linearIssueId) {
+        return this.db.issues.listIssueDependencies(projectId, linearIssueId)
+            .filter((entry) => entry.blockerCurrentLinearStateType !== "completed"
+            && entry.blockerCurrentLinearState?.trim().toLowerCase() !== "done")
+            .map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId);
+    }
 }

package/dist/workflow-wake-resolver.js

@@ -85,12 +85,14 @@ export class WorkflowWakeResolver {
         this.issueSessions = issueSessions;
     }
     peekIssueWake(projectId, linearIssueId) {
-        const explicitWake = this.issueSessions.peekIssueSessionWake(projectId, linearIssueId);
-        if (explicitWake)
-            return explicitWake;
         const issue = this.issues.getIssue(projectId, linearIssueId);
         if (!issue)
             return undefined;
+        if (this.issues.countUnresolvedBlockers(projectId, linearIssueId) > 0)
+            return undefined;
+        const explicitWake = this.issueSessions.peekIssueSessionWake(projectId, linearIssueId);
+        if (explicitWake)
+            return explicitWake;
         const implicitWake = deriveImplicitReactiveWake(issue);
         if (!implicitWake)
             return undefined;

package/package.json

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