patchrelay 0.83.0 → 0.83.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.83.0",
-  "commit": "5e17a07e67bc",
-  "builtAt": "2026-06-14T17:38:15.238Z"
+  "version": "0.83.1",
+  "commit": "87265ce29424",
+  "builtAt": "2026-06-14T18:10:49.183Z"
 }

package/dist/db.js

@@ -87,6 +87,21 @@ export class PatchRelayDatabase {
     assertSchemaReady() {
         assertPatchRelaySchemaReady(this.connection, this.databasePath);
     }
+    describeSchema() {
+        const tableRows = this.connection.prepare(`
+      SELECT name FROM sqlite_master
+      WHERE type = 'table' AND name IN ('issues', 'issue_sessions', 'runs')
+      ORDER BY name
+    `).all();
+        const issueColumns = tableRows.some((row) => row.name === "issues")
+            ? this.connection.prepare("PRAGMA table_info(issues)").all().map((row) => row.name)
+            : [];
+        return {
+            databasePath: this.databasePath,
+            tables: tableRows.map((row) => row.name),
+            issuesVersionColumnPresent: issueColumns.includes("version"),
+        };
+    }
     transaction(fn) {
         return this.connection.transaction(fn)();
     }

package/dist/linear-progress-reporter.js

@@ -1,4 +1,5 @@
 import { deriveLinearProgressFact } from "./linear-progress-facts.js";
+import { isSqliteSchemaReadError } from "./sqlite-errors.js";
 export class LinearProgressReporter {
     db;
     emitActivity;
@@ -11,7 +12,7 @@ export class LinearProgressReporter {
         this.options = options;
     }
     maybeEmitProgress(notification, run) {
-        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+        const issue = this.getIssueWithSchemaRetry(run);
         if (!issue) {
             return;
         }
@@ -73,7 +74,7 @@ export class LinearProgressReporter {
         if (previous?.lastHeartbeatAtMs !== undefined && now - previous.lastHeartbeatAtMs < intervalMs) {
             return;
         }
-        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+        const issue = this.getIssueWithSchemaRetry(run);
         if (!issue) {
             return;
         }
@@ -108,6 +109,18 @@ export class LinearProgressReporter {
     now() {
         return this.options.now?.() ?? Date.now();
     }
+    getIssueWithSchemaRetry(run) {
+        try {
+            return this.db.getIssue(run.projectId, run.linearIssueId);
+        }
+        catch (error) {
+            if (!isSqliteSchemaReadError(error)) {
+                throw error;
+            }
+            this.db.assertSchemaReady();
+            return this.db.getIssue(run.projectId, run.linearIssueId);
+        }
+    }
     clearFailedPublication(runId, channel, meaningKey, publishedAtMs) {
         const current = this.publicationsByRun.get(runId);
         if (!current) {

package/dist/orchestration-parent-wake.js

@@ -1,4 +1,5 @@
 import { classifyIssue } from "./issue-class.js";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.js";
 const WRITER = "orchestration-parent-wake";
 export const ORCHESTRATION_SETTLE_WINDOW_MS = 10_000;
 export function computeOrchestrationSettleUntil(now = Date.now()) {
@@ -23,6 +24,12 @@ function resolveParentIssueIds(db, child) {
     }
     return unique(parentIds);
 }
+function parentHasRunnableWorkflowTask(db, parent) {
+    const reconciliation = reconcileWorkflowTasksForIssue(db, parent);
+    return reconciliation.result.open.some((task) => (task.taskType === "run"
+        && task.runType !== undefined
+        && task.gateAction === "start"));
+}
 export function startOrchestrationSettleWindow(db, issue, now = Date.now()) {
     const settleUntil = computeOrchestrationSettleUntil(now);
     db.issueSessions.commitIssueState({
@@ -70,6 +77,10 @@ export function wakeOrchestrationParentsForChildEvent(params) {
             parentIds.push(parent.linearIssueId);
             continue;
         }
+        if (!parentHasRunnableWorkflowTask(params.db, parent)) {
+            parentIds.push(parent.linearIssueId);
+            continue;
+        }
         params.wakeDispatcher.recordEventAndDispatch(parent.projectId, parent.linearIssueId, {
             eventType: params.eventType,
             eventJson: JSON.stringify({

package/dist/run-notification-handler.js

@@ -234,7 +234,14 @@ export class RunNotificationHandler {
             this.linearSync.maybeEmitProgress(notification, run);
         }
         catch (error) {
-            this.logger.warn({ runId: run.id, projectId: run.projectId, issueId: run.linearIssueId, method: notification.method, error: formatError(error) }, "Linear progress reporting failed");
+            this.logger.warn({
+                runId: run.id,
+                projectId: run.projectId,
+                issueId: run.linearIssueId,
+                method: notification.method,
+                error: formatError(error),
+                storage: this.safeStorageDiagnostics(),
+            }, "Linear progress reporting failed");
         }
     }
     syncCodexPlan(notification, run) {
@@ -257,6 +264,14 @@ export class RunNotificationHandler {
             this.logger.warn({ runId: run.id, issueKey: issue.issueKey, projectId: run.projectId, issueId: run.linearIssueId, method: notification.method, error: formatError(error) }, "Linear plan sync failed");
         }
     }
+    safeStorageDiagnostics() {
+        try {
+            return this.db.describeSchema();
+        }
+        catch {
+            return undefined;
+        }
+    }
 }
 function formatError(error) {
     return error instanceof Error ? error.message : String(error);

package/dist/run-wake-planner.js

@@ -2,6 +2,7 @@ import { getCiRepairBudget, getQueueRepairBudget, getReviewFixBudget, } from "./
 import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
 import { parseRunContextOrWarn, serializeRunContext, tryParseRunContextValue } from "./run-context.js";
 import { assertNever } from "./utils.js";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.js";
 const WRITER = "run-wake-planner";
 function parseObjectJson(raw) {
     if (!raw)
@@ -24,11 +25,22 @@ export class RunWakePlanner {
         this.logger = logger;
     }
     resolveRunWake(issue) {
-        if (this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId) > 0) {
+        const freshIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        if (this.db.issues.countUnresolvedBlockers(freshIssue.projectId, freshIssue.linearIssueId) > 0) {
             return undefined;
         }
-        const sessionWake = this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId);
+        const existingWorkflowTaskWake = this.resolveWorkflowTaskWake(freshIssue);
+        if (existingWorkflowTaskWake)
+            return existingWorkflowTaskWake;
+        this.reconcileWorkflowTasks(freshIssue);
+        const workflowTaskWake = this.resolveWorkflowTaskWake(freshIssue);
+        if (workflowTaskWake)
+            return workflowTaskWake;
+        const sessionWake = this.db.issueSessions.peekIssueSessionWake(freshIssue.projectId, freshIssue.linearIssueId);
         if (sessionWake) {
+            if (this.workflowTasksSuppressSessionWake(freshIssue, sessionWake.wakeReason)) {
+                return undefined;
+            }
             return {
                 runType: sessionWake.runType,
                 context: sessionWake.context,
@@ -37,10 +49,10 @@ export class RunWakePlanner {
                 eventIds: sessionWake.eventIds,
             };
         }
-        const workflowTaskWake = this.resolveWorkflowTaskWake(issue);
-        if (workflowTaskWake)
-            return workflowTaskWake;
-        const implicitWake = this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId);
+        if (this.workflowTasksSuppressSessionWake(freshIssue, undefined)) {
+            return undefined;
+        }
+        const implicitWake = this.db.workflowWakes.peekIssueWake(freshIssue.projectId, freshIssue.linearIssueId);
         if (!implicitWake)
             return undefined;
         return {
@@ -72,6 +84,56 @@ export class RunWakePlanner {
             eventIds: [],
         };
     }
+    reconcileWorkflowTasks(issue) {
+        try {
+            reconcileWorkflowTasksForIssue(this.db, issue);
+        }
+        catch (error) {
+            this.logger?.warn({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                error: error instanceof Error ? error.message : String(error),
+            }, "Workflow task reconciliation failed while planning run wake");
+        }
+    }
+    workflowTasksSuppressSessionWake(issue, wakeReason) {
+        const openTasks = this.db.workflowTasks.listOpenTasks(issue.projectId, issue.linearIssueId);
+        if (openTasks.length === 0)
+            return false;
+        if (openTasks.some((task) => task.taskType === "run" && task.gateAction === "start" && task.runType !== undefined)) {
+            return false;
+        }
+        if (!openTasks.some((task) => this.isBlockingWorkflowGate(task)))
+            return false;
+        if (!openTasks.every((task) => task.taskId === "wait:input")) {
+            return true;
+        }
+        return wakeReason !== "direct_reply"
+            && wakeReason !== "followup_prompt"
+            && wakeReason !== "followup_comment"
+            && wakeReason !== "human_instruction"
+            && wakeReason !== "operator_prompt"
+            && wakeReason !== "completion_check_continue";
+    }
+    isBlockingWorkflowGate(task) {
+        if (task.taskId === "wait:input")
+            return true;
+        if (task.taskId === "wait:children" || task.taskId === "wait:blockers" || task.taskId.startsWith("wait:active-run:")) {
+            return true;
+        }
+        if (task.taskId === "wait:authority") {
+            return this.workflowAuthorityObserved(task.projectId, task.subjectId);
+        }
+        return task.taskType === "verify" || task.taskType === "ask" || task.taskType === "escalate" || task.taskType === "publish";
+    }
+    workflowAuthorityObserved(projectId, linearIssueId) {
+        return this.db.workflowObservations
+            .listObservations(projectId, linearIssueId)
+            .some((observation) => (observation.type === "linear.delegated"
+            || observation.type === "linear.undelegated"
+            || observation.type === "operator.authority_changed"));
+    }
     appendWakeEventWithLease(lease, issue, runType, context, dedupeScope) {
         let eventType;
         let dedupeKey;

package/dist/service-runtime.js

@@ -1,5 +1,6 @@
 import { SerialWorkQueue } from "./service-queue.js";
 import { retrySqliteLockedQueueFailure } from "./queue-failure-policy.js";
+import { isSqliteSchemaReadError } from "./sqlite-errors.js";
 const ISSUE_KEY_DELIMITER = "::";
 const DEFAULT_RECONCILE_INTERVAL_MS = 5_000;
 const DEFAULT_RECONCILE_TIMEOUT_MS = 60_000;
@@ -135,7 +136,7 @@ export class ServiceRuntime {
         }
         this.reconcileInProgress = true;
         try {
-            await promiseWithTimeout(this.runReconciler.reconcileActiveRuns(), this.options.reconcileTimeoutMs ?? DEFAULT_RECONCILE_TIMEOUT_MS, "Background active-run reconciliation");
+            await this.reconcileActiveRunsWithSchemaRetry();
             // Pick up issues that became ready outside the webhook path
             // (e.g. CLI retry, manual DB edits) without requiring a restart.
             for (const issue of this.readyIssueSource.listIssuesReadyForExecution()) {
@@ -143,7 +144,10 @@ export class ServiceRuntime {
             }
         }
         catch (error) {
-            this.logger.warn({ error: error instanceof Error ? error.message : String(error) }, "Background active-run reconciliation failed");
+            this.logger.warn({
+                error: error instanceof Error ? error.message : String(error),
+                storage: this.safeStorageDiagnostics(),
+            }, "Background active-run reconciliation failed");
         }
         finally {
             this.reconcileInProgress = false;
@@ -152,6 +156,30 @@ export class ServiceRuntime {
             }
         }
     }
+    async reconcileActiveRunsWithSchemaRetry() {
+        try {
+            await this.reconcileActiveRunsOnce();
+        }
+        catch (error) {
+            if (!isSqliteSchemaReadError(error) || !this.options.assertStorageReady) {
+                throw error;
+            }
+            this.options.assertStorageReady();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            await this.reconcileActiveRunsOnce();
+        }
+    }
+    async reconcileActiveRunsOnce() {
+        await promiseWithTimeout(this.runReconciler.reconcileActiveRuns(), this.options.reconcileTimeoutMs ?? DEFAULT_RECONCILE_TIMEOUT_MS, "Background active-run reconciliation");
+    }
+    safeStorageDiagnostics() {
+        try {
+            return this.options.describeStorage?.();
+        }
+        catch {
+            return undefined;
+        }
+    }
     getMaxActiveIssueRuns() {
         const configured = this.options.maxActiveIssueRuns ?? DEFAULT_MAX_ACTIVE_ISSUE_RUNS;
         return Math.max(1, Math.floor(configured));

package/dist/service.js

@@ -77,6 +77,9 @@ export class PatchRelayService {
             processIssue: async (item) => {
                 await this.orchestrator.run(item);
             },
+        }, {
+            assertStorageReady: () => db.assertSchemaReady(),
+            describeStorage: () => db.describeSchema(),
         });
         enqueueIssue = (projectId, issueId) => runtime.enqueueIssue(projectId, issueId);
         this.oauthService = new LinearOAuthService(config, { linearInstallations: db.linearInstallations }, logger);

package/dist/sqlite-errors.js

@@ -0,0 +1,5 @@
+export function isSqliteSchemaReadError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("no such table:")
+        || message.includes("no such column:");
+}

package/dist/wake-dispatcher.js

@@ -1,4 +1,5 @@
 import { emitTelemetry, noopTelemetry } from "./telemetry.js";
+import { reconcileWorkflowTasksForIssue } from "./workflow-task-reconciler.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
@@ -32,22 +33,82 @@ export class WakeDispatcher {
         this.feed = feed;
         this.telemetry = telemetry;
     }
-    peekRunnableWorkflowTask(projectId, linearIssueId) {
-        return this.db.workflowTasks
-            .listOpenRunnableTasks(projectId)
-            .find((task) => task.subjectId === linearIssueId && task.runType !== undefined);
+    listOpenWorkflowTasks(projectId, linearIssueId) {
+        return this.db.workflowTasks.listOpenTasks(projectId, linearIssueId);
     }
-    resolveDispatchableWake(projectId, linearIssueId, issue) {
-        const sessionWake = this.db.issueSessions.peekIssueSessionWake(projectId, linearIssueId);
-        if (sessionWake) {
+    reconcileOpenWorkflowTasks(issue, options) {
+        try {
+            return reconcileWorkflowTasksForIssue(this.db, issue, options).result.open;
+        }
+        catch (error) {
+            this.logger.warn({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                error: error instanceof Error ? error.message : String(error),
+            }, "Workflow task reconciliation failed while resolving wake");
+            return this.listOpenWorkflowTasks(issue.projectId, issue.linearIssueId);
+        }
+    }
+    peekRunnableWorkflowTask(projectId, linearIssueId, openTasks) {
+        return (openTasks ?? this.db.workflowTasks.listOpenRunnableTasks(projectId))
+            .find((task) => (task.subjectId === linearIssueId
+            && task.taskType === "run"
+            && task.gateAction === "start"
+            && task.runType !== undefined));
+    }
+    workflowAuthorityObserved(projectId, linearIssueId) {
+        return this.db.workflowObservations
+            .listObservations(projectId, linearIssueId)
+            .some((observation) => (observation.type === "linear.delegated"
+            || observation.type === "linear.undelegated"
+            || observation.type === "operator.authority_changed"));
+    }
+    sessionWakeCanAnswerInputWait(openTasks, wakeReason) {
+        if (openTasks.length === 0 || !openTasks.every((task) => task.taskId === "wait:input")) {
+            return false;
+        }
+        return wakeReason === "direct_reply"
+            || wakeReason === "followup_prompt"
+            || wakeReason === "followup_comment"
+            || wakeReason === "human_instruction"
+            || wakeReason === "operator_prompt"
+            || wakeReason === "completion_check_continue";
+    }
+    workflowTasksSuppressSessionWake(openTasks, wakeReason) {
+        if (openTasks.length === 0)
+            return false;
+        if (this.peekRunnableWorkflowTask(openTasks[0].projectId, openTasks[0].subjectId, openTasks))
+            return false;
+        if (!openTasks.some((task) => this.isBlockingWorkflowGate(task)))
+            return false;
+        return !this.sessionWakeCanAnswerInputWait(openTasks, wakeReason);
+    }
+    isBlockingWorkflowGate(task) {
+        if (task.taskId === "wait:input")
+            return true;
+        if (task.taskId === "wait:children" || task.taskId === "wait:blockers" || task.taskId.startsWith("wait:active-run:")) {
+            return true;
+        }
+        if (task.taskId === "wait:authority") {
+            return this.workflowAuthorityObserved(task.projectId, task.subjectId);
+        }
+        return task.taskType === "verify" || task.taskType === "ask" || task.taskType === "escalate" || task.taskType === "publish";
+    }
+    resolveDispatchableWake(projectId, linearIssueId, issue, options) {
+        const existingWorkflowTasks = this.listOpenWorkflowTasks(projectId, linearIssueId);
+        const existingWorkflowTask = this.peekRunnableWorkflowTask(projectId, linearIssueId, existingWorkflowTasks);
+        if (existingWorkflowTask?.runType) {
             return {
-                runType: sessionWake.runType,
-                ...(sessionWake.wakeReason ? { wakeReason: sessionWake.wakeReason } : {}),
-                eventIds: sessionWake.eventIds,
-                source: "session_event",
+                runType: existingWorkflowTask.runType,
+                wakeReason: existingWorkflowTask.taskId,
+                eventIds: [],
+                source: "workflow_task",
             };
         }
-        const workflowTask = this.peekRunnableWorkflowTask(projectId, linearIssueId);
+        const freshIssue = this.db.issues.getIssue(projectId, linearIssueId) ?? issue;
+        const openWorkflowTasks = this.reconcileOpenWorkflowTasks(freshIssue, options);
+        const workflowTask = this.peekRunnableWorkflowTask(projectId, linearIssueId, openWorkflowTasks);
         if (workflowTask?.runType) {
             return {
                 runType: workflowTask.runType,
@@ -56,6 +117,21 @@ export class WakeDispatcher {
                 source: "workflow_task",
             };
         }
+        const sessionWake = this.db.issueSessions.peekIssueSessionWake(projectId, linearIssueId);
+        if (sessionWake) {
+            if (this.workflowTasksSuppressSessionWake(openWorkflowTasks, sessionWake.wakeReason)) {
+                return undefined;
+            }
+            return {
+                runType: sessionWake.runType,
+                ...(sessionWake.wakeReason ? { wakeReason: sessionWake.wakeReason } : {}),
+                eventIds: sessionWake.eventIds,
+                source: "session_event",
+            };
+        }
+        if (this.workflowTasksSuppressSessionWake(openWorkflowTasks, undefined)) {
+            return undefined;
+        }
         if (issue.pendingRunType) {
             return {
                 runType: issue.pendingRunType,
@@ -279,7 +355,17 @@ export class WakeDispatcher {
             runType: params.run.runType,
         });
         const issue = this.db.issues.getIssue(params.run.projectId, params.run.linearIssueId);
-        const wake = issue ? this.resolveDispatchableWake(params.run.projectId, params.run.linearIssueId, issue) : undefined;
+        if (issue?.factoryState === "done" || issue?.factoryState === "failed" || issue?.factoryState === "escalated" || issue?.prState === "merged") {
+            emitTelemetry(this.telemetry, {
+                type: "wake.suppressed",
+                projectId: params.run.projectId,
+                linearIssueId: params.run.linearIssueId,
+                ...(params.issueKey ? { issueKey: params.issueKey } : {}),
+                reason: "terminal_event",
+            });
+            return undefined;
+        }
+        const wake = issue ? this.resolveDispatchableWake(params.run.projectId, params.run.linearIssueId, issue, { ignoreDetachedActiveRuns: true }) : undefined;
         if (!wake) {
             emitTelemetry(this.telemetry, {
                 type: "wake.suppressed",

package/dist/workflow-runtime.js

@@ -197,6 +197,9 @@ export function deriveWorkflowTasks(snapshot) {
     if (snapshot.status === "done") {
         return [];
     }
+    if (snapshot.status === "failed") {
+        return [];
+    }
     if (snapshot.activeRun) {
         return [{
                 id: `wait:active-run:${snapshot.activeRun.id}`,

package/dist/workflow-task-reconciler.js

@@ -2,13 +2,21 @@ import { evaluateTaskStart, projectWorkflowSnapshot, } from "./workflow-runtime.
 function isActiveRun(run) {
     return run.status === "queued" || run.status === "running";
 }
-function resolveActiveRunSnapshot(db, issue) {
+function resolveActiveRunSnapshot(db, issue, options) {
     const pinnedRun = issue.activeRunId !== undefined ? db.runs.getRunById(issue.activeRunId) : undefined;
-    const run = pinnedRun && isActiveRun(pinnedRun)
-        ? pinnedRun
-        : db.runs.listRunsForIssue(issue.projectId, issue.linearIssueId)
-            .filter(isActiveRun)
-            .at(-1);
+    if (pinnedRun && isActiveRun(pinnedRun)) {
+        return {
+            id: pinnedRun.id,
+            runType: pinnedRun.runType,
+            authorityEpoch: pinnedRun.authorityEpoch,
+            status: pinnedRun.status,
+        };
+    }
+    if (options?.ignoreDetachedActiveRuns)
+        return undefined;
+    const run = db.runs.listRunsForIssue(issue.projectId, issue.linearIssueId)
+        .filter(isActiveRun)
+        .at(-1);
     if (!run)
         return undefined;
     return {
@@ -34,8 +42,8 @@ function readinessForTask(snapshot, task) {
     }
     return evaluateTaskStart(snapshot, task);
 }
-export function buildWorkflowSnapshotForIssue(db, issue) {
-    const activeRun = resolveActiveRunSnapshot(db, issue);
+export function buildWorkflowSnapshotForIssue(db, issue, options) {
+    const activeRun = resolveActiveRunSnapshot(db, issue, options);
     return projectWorkflowSnapshot({
         issue,
         observations: db.workflowObservations.listObservations(issue.projectId, issue.linearIssueId),
@@ -45,8 +53,8 @@ export function buildWorkflowSnapshotForIssue(db, issue) {
         ...(activeRun ? { activeRun } : {}),
     });
 }
-export function reconcileWorkflowTasksForIssue(db, issue) {
-    const snapshot = buildWorkflowSnapshotForIssue(db, issue);
+export function reconcileWorkflowTasksForIssue(db, issue, options) {
+    const snapshot = buildWorkflowSnapshotForIssue(db, issue, options);
     const result = db.workflowTasks.reconcileTasks({
         projectId: issue.projectId,
         subjectId: issue.linearIssueId,

package/package.json

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