patchrelay 0.74.6 → 0.74.8

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.8",
+  "commit": "5016ef557bde",
+  "builtAt": "2026-05-29T12:02:10.583Z"
 }

package/dist/codex-status.js

@@ -1,7 +1,8 @@
 import { spawnSync } from "node:child_process";
 const CODEX_STATUS_TIMEOUT_MS = 15_000;
 function stripAnsiCodes(value) {
-    return value.replace(/\u001b\[[0-9;]*m/g, "");
+    const escape = String.fromCharCode(27);
+    return value.replace(new RegExp(`${escape}\\[[0-9;]*m`, "g"), "");
 }
 function parseAccountLine(output) {
     const lines = output.split(/\r?\n/);

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/index.js

@@ -1,7 +1,19 @@
 #!/usr/bin/env node
 import { dirname } from "node:path";
 import { runCli } from "./cli/index.js";
+function suppressNodeSqliteExperimentalWarning() {
+    const originalEmitWarning = process.emitWarning;
+    process.emitWarning = function emitWarningWithoutNodeSqliteNoise(warning, optionsOrType, codeOrCtor, ctor) {
+        const message = warning instanceof Error ? warning.message : warning;
+        const type = typeof optionsOrType === "string" ? optionsOrType : optionsOrType?.type;
+        if (type === "ExperimentalWarning" && message.includes("SQLite is an experimental feature")) {
+            return;
+        }
+        return originalEmitWarning.call(process, warning, optionsOrType, codeOrCtor, ctor);
+    };
+}
 async function main() {
+    suppressNodeSqliteExperimentalWarning();
     const cliExitCode = await runCli(process.argv.slice(2));
     if (cliExitCode !== -1) {
         process.exitCode = cliExitCode;

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/preflight.js

@@ -117,6 +117,9 @@ async function checkLinearApi(graphqlUrl) {
         if (response.ok) {
             return pass("linear_api", `Linear GraphQL API is reachable at ${graphqlUrl}`);
         }
+        if (response.status === 401 || response.status === 403) {
+            return pass("linear_api", `Linear GraphQL API is reachable at ${graphqlUrl} (authentication required)`);
+        }
         return warn("linear_api", `Linear GraphQL API returned ${response.status} — may be unreachable or rate-limited`);
     }
     catch (error) {