patchrelay 0.36.7 → 0.36.8

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.36.7",
-  "commit": "93dd74dadf6f",
-  "builtAt": "2026-04-09T11:23:49.821Z"
+  "version": "0.36.8",
+  "commit": "a62440fe88ab",
+  "builtAt": "2026-04-09T12:45:27.217Z"
 }

package/dist/cli/cluster-health.js

@@ -31,7 +31,7 @@ export async function collectClusterHealth(config, db, runCommand) {
         });
         return {
             issue,
-            session: db.getIssueSession(issue.projectId, issue.linearIssueId),
+            session: db.issueSessions.getIssueSession(issue.projectId, issue.linearIssueId),
             blockedBy,
             missingTrackedBlockers,
             ageMs: Math.max(0, now - Date.parse(issue.updatedAt || new Date(0).toISOString())),

package/dist/cli/data.js

@@ -42,7 +42,7 @@ function summarizeThread(thread, latestTimestampSeen) {
     };
 }
 function latestEventTimestamp(db, runId) {
-    const events = db.listThreadEvents(runId);
+    const events = db.runs.listThreadEvents(runId);
     return events.at(-1)?.createdAt;
 }
 function parseObjectJson(value) {
@@ -95,8 +95,8 @@ export class CliDataAccess extends CliOperatorApiClient {
         if (!issue)
             return undefined;
         const dbIssue = this.db.getIssueByKey(issueKey);
-        const activeRun = dbIssue.activeRunId ? this.db.getRun(dbIssue.activeRunId) : undefined;
-        const latestRun = this.db.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+        const activeRun = dbIssue.activeRunId ? this.db.runs.getRunById(dbIssue.activeRunId) : undefined;
+        const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
         const latestReport = normalizeStageReport(latestRun?.reportJson, latestRun?.status);
         const latestSummary = safeJsonParse(latestRun?.summaryJson);
         const statusNote = latestReport?.assistantMessages.at(-1) ??
@@ -121,7 +121,7 @@ export class CliDataAccess extends CliOperatorApiClient {
         if (!issue)
             return undefined;
         const dbIssue = this.db.getIssueByKey(issueKey);
-        const run = dbIssue.activeRunId ? this.db.getRun(dbIssue.activeRunId) : undefined;
+        const run = dbIssue.activeRunId ? this.db.runs.getRunById(dbIssue.activeRunId) : undefined;
         if (!run)
             return undefined;
         const live = run.threadId &&
@@ -180,7 +180,7 @@ export class CliDataAccess extends CliOperatorApiClient {
         if (!issue)
             return undefined;
         const dbIssue = this.db.getIssueByKey(issueKey);
-        const issueSession = this.db.getIssueSession(issue.projectId, issue.linearIssueId);
+        const issueSession = this.db.issueSessions.getIssueSession(issue.projectId, issue.linearIssueId);
         if (dbIssue.activeRunId !== undefined) {
             throw new Error(`Issue ${issueKey} already has an active run.`);
         }
@@ -215,7 +215,7 @@ export class CliDataAccess extends CliOperatorApiClient {
         if (!issue)
             return undefined;
         const dbIssue = this.db.getIssueByKey(issueKey);
-        const runs = this.db.listRunsForIssue(issue.projectId, issue.linearIssueId);
+        const runs = this.db.runs.listRunsForIssue(issue.projectId, issue.linearIssueId);
         const sessions = runs
             .slice()
             .reverse()
@@ -230,7 +230,7 @@ export class CliDataAccess extends CliOperatorApiClient {
                 ...(run.parentThreadId ? { parentThreadId: run.parentThreadId } : {}),
                 ...(summary ? { summary } : {}),
                 ...(run.failureReason ? { failureReason: run.failureReason } : {}),
-                eventCount: this.db.listThreadEvents(run.id).length,
+                eventCount: this.db.runs.listThreadEvents(run.id).length,
                 startedAt: run.startedAt,
                 ...(run.endedAt ? { endedAt: run.endedAt } : {}),
                 isCurrentThread: run.threadId !== undefined && run.threadId === dbIssue.threadId,
@@ -247,7 +247,7 @@ export class CliDataAccess extends CliOperatorApiClient {
         if (runType === "queue_repair") {
             const queueIncident = parseObjectJson(issue.lastQueueIncidentJson);
             const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
-            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 eventType: "merge_steward_incident",
@@ -262,7 +262,7 @@ export class CliDataAccess extends CliOperatorApiClient {
         }
         if (runType === "ci_repair") {
             const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
-            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 eventType: "settled_red_ci",
@@ -275,7 +275,7 @@ export class CliDataAccess extends CliOperatorApiClient {
             return;
         }
         if (runType === "review_fix" || runType === "branch_upkeep") {
-            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 eventType: "review_changes_requested",
@@ -290,7 +290,7 @@ export class CliDataAccess extends CliOperatorApiClient {
             });
             return;
         }
-        this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             eventType: "delegated",

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

@@ -0,0 +1,292 @@
+import { deriveSessionWakePlan } from "../issue-session-events.js";
+import { isoNow } from "./shared.js";
+export class IssueSessionStore {
+    connection;
+    mapIssueSessionRow;
+    mapIssueSessionEventRow;
+    getIssue;
+    deriveImplicitReactiveWake;
+    transaction;
+    upsertIssue;
+    finishRun;
+    updateRunThread;
+    setBranchOwner;
+    constructor(connection, mapIssueSessionRow, mapIssueSessionEventRow, getIssue, deriveImplicitReactiveWake, transaction, upsertIssue, finishRun, updateRunThread, setBranchOwner) {
+        this.connection = connection;
+        this.mapIssueSessionRow = mapIssueSessionRow;
+        this.mapIssueSessionEventRow = mapIssueSessionEventRow;
+        this.getIssue = getIssue;
+        this.deriveImplicitReactiveWake = deriveImplicitReactiveWake;
+        this.transaction = transaction;
+        this.upsertIssue = upsertIssue;
+        this.finishRun = finishRun;
+        this.updateRunThread = updateRunThread;
+        this.setBranchOwner = setBranchOwner;
+    }
+    getIssueSession(projectId, linearIssueId) {
+        const row = this.connection
+            .prepare("SELECT * FROM issue_sessions WHERE project_id = ? AND linear_issue_id = ?")
+            .get(projectId, linearIssueId);
+        return row ? this.mapIssueSessionRow(row) : undefined;
+    }
+    getIssueSessionByKey(issueKey) {
+        const row = this.connection.prepare("SELECT * FROM issue_sessions WHERE issue_key = ?").get(issueKey);
+        return row ? this.mapIssueSessionRow(row) : undefined;
+    }
+    appendIssueSessionEvent(params) {
+        if (params.dedupeKey) {
+            const existing = this.connection.prepare(`
+        SELECT * FROM issue_session_events
+        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)
+                return this.mapIssueSessionEventRow(existing);
+        }
+        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));
+    }
+    appendIssueSessionEventWithLease(lease, params) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => this.appendIssueSessionEvent(params));
+    }
+    appendIssueSessionEventRespectingActiveLease(projectId, linearIssueId, params) {
+        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
+        if (!lease) {
+            return this.appendIssueSessionEvent(params);
+        }
+        return this.appendIssueSessionEventWithLease(lease, params);
+    }
+    getIssueSessionEvent(id) {
+        const row = this.connection.prepare("SELECT * FROM issue_session_events WHERE id = ?").get(id);
+        return row ? this.mapIssueSessionEventRow(row) : undefined;
+    }
+    listIssueSessionEvents(projectId, linearIssueId, options) {
+        const conditions = ["project_id = ?", "linear_issue_id = ?"];
+        const values = [projectId, linearIssueId];
+        if (options?.pendingOnly) {
+            conditions.push("processed_at IS NULL");
+        }
+        let query = `SELECT * FROM issue_session_events WHERE ${conditions.join(" AND ")} ORDER BY id`;
+        if (options?.limit !== undefined) {
+            query += " LIMIT ?";
+            values.push(options.limit);
+        }
+        const rows = this.connection.prepare(query).all(...values);
+        return rows.map(this.mapIssueSessionEventRow);
+    }
+    consumeIssueSessionEvents(projectId, linearIssueId, eventIds, runId) {
+        if (eventIds.length === 0)
+            return;
+        const now = isoNow();
+        const placeholders = eventIds.map(() => "?").join(", ");
+        this.connection.prepare(`
+      UPDATE issue_session_events
+      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);
+    }
+    clearPendingIssueSessionEvents(projectId, linearIssueId) {
+        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);
+    }
+    hasPendingIssueSessionEvents(projectId, linearIssueId) {
+        const row = this.connection.prepare(`
+      SELECT 1
+      FROM issue_session_events
+      WHERE project_id = ? AND linear_issue_id = ? AND processed_at IS NULL
+      LIMIT 1
+    `).get(projectId, linearIssueId);
+        return row !== undefined;
+    }
+    peekIssueSessionWake(projectId, linearIssueId) {
+        const issue = this.getIssue(projectId, linearIssueId);
+        if (!issue)
+            return undefined;
+        const events = this.listIssueSessionEvents(projectId, linearIssueId, { pendingOnly: true });
+        const plan = deriveSessionWakePlan(issue, events);
+        if (plan?.runType) {
+            return {
+                eventIds: events.map((event) => event.id),
+                runType: plan.runType,
+                context: plan.context,
+                ...(plan.wakeReason ? { wakeReason: plan.wakeReason } : {}),
+                resumeThread: plan.resumeThread,
+            };
+        }
+        const implicitWake = this.deriveImplicitReactiveWake(issue);
+        if (!implicitWake)
+            return undefined;
+        return {
+            eventIds: [],
+            runType: implicitWake.runType,
+            context: implicitWake.context,
+            wakeReason: implicitWake.wakeReason,
+            resumeThread: false,
+        };
+    }
+    acquireIssueSessionLease(params) {
+        const now = params.now ?? isoNow();
+        const result = this.connection.prepare(`
+      UPDATE issue_sessions
+      SET lease_id = ?, worker_id = ?, leased_until = ?, updated_at = ?
+      WHERE project_id = ? AND linear_issue_id = ?
+        AND (leased_until IS NULL OR leased_until <= ? OR lease_id = ?)
+    `).run(params.leaseId, params.workerId, params.leasedUntil, now, params.projectId, params.linearIssueId, now, params.leaseId);
+        return Number(result.changes ?? 0) > 0;
+    }
+    forceAcquireIssueSessionLease(params) {
+        const now = params.now ?? isoNow();
+        const result = this.connection.prepare(`
+      UPDATE issue_sessions
+      SET lease_id = ?, worker_id = ?, leased_until = ?, updated_at = ?
+      WHERE project_id = ? AND linear_issue_id = ?
+    `).run(params.leaseId, params.workerId, params.leasedUntil, now, params.projectId, params.linearIssueId);
+        return Number(result.changes ?? 0) > 0;
+    }
+    renewIssueSessionLease(params) {
+        const now = params.now ?? isoNow();
+        const result = this.connection.prepare(`
+      UPDATE issue_sessions
+      SET leased_until = ?, updated_at = ?
+      WHERE project_id = ? AND linear_issue_id = ? AND lease_id = ?
+    `).run(params.leasedUntil, now, params.projectId, params.linearIssueId, params.leaseId);
+        return Number(result.changes ?? 0) > 0;
+    }
+    releaseIssueSessionLease(projectId, linearIssueId, leaseId) {
+        this.connection.prepare(`
+      UPDATE issue_sessions
+      SET lease_id = NULL, worker_id = NULL, leased_until = NULL, updated_at = ?
+      WHERE project_id = ? AND linear_issue_id = ? AND (? IS NULL OR lease_id = ?)
+    `).run(isoNow(), projectId, linearIssueId, leaseId ?? null, leaseId ?? null);
+    }
+    releaseExpiredIssueSessionLeases(now = isoNow()) {
+        this.connection.prepare(`
+      UPDATE issue_sessions
+      SET lease_id = NULL, worker_id = NULL, leased_until = NULL, updated_at = ?
+      WHERE leased_until IS NOT NULL AND leased_until <= ?
+    `).run(now, now);
+    }
+    hasActiveIssueSessionLease(projectId, linearIssueId, leaseId, now = isoNow()) {
+        const row = this.connection.prepare(`
+      SELECT 1
+      FROM issue_sessions
+      WHERE project_id = ? AND linear_issue_id = ? AND lease_id = ?
+        AND leased_until IS NOT NULL
+        AND leased_until > ?
+      LIMIT 1
+    `).get(projectId, linearIssueId, leaseId, now);
+        return row !== undefined;
+    }
+    getActiveIssueSessionLease(projectId, linearIssueId, now = isoNow()) {
+        const row = this.connection.prepare(`
+      SELECT lease_id
+      FROM issue_sessions
+      WHERE project_id = ? AND linear_issue_id = ?
+        AND lease_id IS NOT NULL
+        AND leased_until IS NOT NULL
+        AND leased_until > ?
+      LIMIT 1
+    `).get(projectId, linearIssueId, now);
+        const leaseId = typeof row?.lease_id === "string" ? row.lease_id : undefined;
+        if (!leaseId)
+            return undefined;
+        return { projectId, linearIssueId, leaseId };
+    }
+    withIssueSessionLease(projectId, linearIssueId, leaseId, fn) {
+        return this.transaction(() => {
+            if (!this.hasActiveIssueSessionLease(projectId, linearIssueId, leaseId)) {
+                return undefined;
+            }
+            return fn();
+        });
+    }
+    upsertIssueWithLease(lease, params) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => this.upsertIssue(params));
+    }
+    upsertIssueRespectingActiveLease(projectId, linearIssueId, params) {
+        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
+        if (!lease) {
+            return this.upsertIssue(params);
+        }
+        return this.upsertIssueWithLease(lease, params);
+    }
+    finishRunWithLease(lease, runId, params) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.finishRun(runId, params);
+            return true;
+        }) ?? false;
+    }
+    finishRunRespectingActiveLease(projectId, linearIssueId, runId, params) {
+        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
+        if (!lease) {
+            this.finishRun(runId, params);
+            return true;
+        }
+        return this.finishRunWithLease(lease, runId, params);
+    }
+    updateRunThreadWithLease(lease, runId, params) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.updateRunThread(runId, params);
+            return true;
+        }) ?? false;
+    }
+    consumeIssueSessionEventsWithLease(lease, eventIds, runId) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.consumeIssueSessionEvents(lease.projectId, lease.linearIssueId, eventIds, runId);
+            return true;
+        }) ?? false;
+    }
+    clearPendingIssueSessionEventsWithLease(lease) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.clearPendingIssueSessionEvents(lease.projectId, lease.linearIssueId);
+            return true;
+        }) ?? false;
+    }
+    clearPendingIssueSessionEventsRespectingActiveLease(projectId, linearIssueId) {
+        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
+        if (!lease) {
+            this.clearPendingIssueSessionEvents(projectId, linearIssueId);
+            return true;
+        }
+        return this.clearPendingIssueSessionEventsWithLease(lease);
+    }
+    setIssueSessionLastWakeReasonWithLease(lease, lastWakeReason) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.setIssueSessionLastWakeReason(lease.projectId, lease.linearIssueId, lastWakeReason);
+            return true;
+        }) ?? false;
+    }
+    setIssueSessionLastWakeReason(projectId, linearIssueId, lastWakeReason) {
+        this.connection.prepare(`
+      UPDATE issue_sessions
+      SET last_wake_reason = ?, updated_at = ?
+      WHERE project_id = ? AND linear_issue_id = ?
+    `).run(lastWakeReason ?? null, isoNow(), projectId, linearIssueId);
+    }
+    setBranchOwnerWithLease(lease, owner) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.setBranchOwner(lease.projectId, lease.linearIssueId, owner);
+            return true;
+        }) ?? false;
+    }
+    setBranchOwnerRespectingActiveLease(projectId, linearIssueId, owner) {
+        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
+        if (!lease) {
+            this.setBranchOwner(projectId, linearIssueId, owner);
+            return true;
+        }
+        return this.setBranchOwnerWithLease(lease, owner);
+    }
+    releaseIssueSessionLeaseRespectingActiveLease(projectId, linearIssueId) {
+        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
+        this.releaseIssueSessionLease(projectId, linearIssueId, lease?.leaseId);
+    }
+}

package/dist/db/run-store.js

@@ -0,0 +1,127 @@
+import { extractLatestAssistantSummary } from "../issue-session-events.js";
+import { isoNow } from "./shared.js";
+export class RunStore {
+    connection;
+    mapRunRow;
+    getRun;
+    getIssue;
+    syncIssueSessionFromIssue;
+    constructor(connection, mapRunRow, getRun, getIssue, syncIssueSessionFromIssue) {
+        this.connection = connection;
+        this.mapRunRow = mapRunRow;
+        this.getRun = getRun;
+        this.getIssue = getIssue;
+        this.syncIssueSessionFromIssue = syncIssueSessionFromIssue;
+    }
+    createRun(params) {
+        const now = isoNow();
+        const result = this.connection.prepare(`
+      INSERT INTO runs (issue_id, project_id, linear_issue_id, run_type, status, source_head_sha, prompt_text, started_at)
+      VALUES (?, ?, ?, ?, 'queued', ?, ?, ?)
+    `).run(params.issueId, params.projectId, params.linearIssueId, params.runType, params.sourceHeadSha ?? null, params.promptText ?? null, now);
+        const run = this.getRun(Number(result.lastInsertRowid));
+        const issue = this.getIssue(params.projectId, params.linearIssueId);
+        if (issue) {
+            this.syncIssueSessionFromIssue(issue, { lastRunType: run.runType });
+        }
+        return run;
+    }
+    getRunById(id) {
+        const row = this.connection.prepare("SELECT * FROM runs WHERE id = ?").get(id);
+        return row ? this.mapRunRow(row) : undefined;
+    }
+    getRunByThreadId(threadId) {
+        const row = this.connection.prepare("SELECT * FROM runs WHERE thread_id = ?").get(threadId);
+        return row ? this.mapRunRow(row) : undefined;
+    }
+    listRunsForIssue(projectId, linearIssueId) {
+        const rows = this.connection
+            .prepare("SELECT * FROM runs WHERE project_id = ? AND linear_issue_id = ? ORDER BY id")
+            .all(projectId, linearIssueId);
+        return rows.map(this.mapRunRow);
+    }
+    getLatestRunForIssue(projectId, linearIssueId) {
+        const row = this.connection
+            .prepare("SELECT * FROM runs WHERE project_id = ? AND linear_issue_id = ? ORDER BY id DESC LIMIT 1")
+            .get(projectId, linearIssueId);
+        return row ? this.mapRunRow(row) : undefined;
+    }
+    listActiveRuns() {
+        const rows = this.connection
+            .prepare("SELECT * FROM runs WHERE status IN ('queued', 'running')")
+            .all();
+        return rows.map(this.mapRunRow);
+    }
+    listRunningRuns() {
+        const rows = this.connection
+            .prepare("SELECT * FROM runs WHERE status IN ('running', 'queued')")
+            .all();
+        return rows.map(this.mapRunRow);
+    }
+    updateRunThread(runId, params) {
+        this.connection.prepare(`
+      UPDATE runs SET
+        thread_id = ?,
+        parent_thread_id = COALESCE(?, parent_thread_id),
+        turn_id = COALESCE(?, turn_id),
+        status = 'running'
+      WHERE id = ?
+        AND ended_at IS NULL
+        AND status IN ('queued', 'running')
+    `).run(params.threadId, params.parentThreadId ?? null, params.turnId ?? null, runId);
+        const run = this.getRun(runId);
+        if (!run)
+            return;
+        const issue = this.getIssue(run.projectId, run.linearIssueId);
+        if (issue) {
+            this.syncIssueSessionFromIssue(issue);
+        }
+    }
+    updateRunTurnId(runId, turnId) {
+        this.connection.prepare("UPDATE runs SET turn_id = ? WHERE id = ?").run(turnId, runId);
+    }
+    finishRun(runId, params) {
+        const now = isoNow();
+        this.connection.prepare(`
+      UPDATE runs SET
+        status = ?,
+        thread_id = COALESCE(?, thread_id),
+        turn_id = COALESCE(?, turn_id),
+        failure_reason = COALESCE(?, failure_reason),
+        summary_json = COALESCE(?, summary_json),
+        report_json = COALESCE(?, report_json),
+        ended_at = ?
+      WHERE id = ?
+    `).run(params.status, params.threadId ?? null, params.turnId ?? null, params.failureReason ?? null, params.summaryJson ?? null, params.reportJson ?? null, now, runId);
+        const run = this.getRun(runId);
+        if (!run)
+            return;
+        const issue = this.getIssue(run.projectId, run.linearIssueId);
+        if (issue) {
+            this.syncIssueSessionFromIssue(issue, {
+                summaryText: extractLatestAssistantSummary(this.getRun(runId) ?? run),
+                lastRunType: run.runType,
+            });
+        }
+    }
+    saveThreadEvent(params) {
+        this.connection.prepare(`
+      INSERT INTO run_thread_events (run_id, thread_id, turn_id, method, event_json, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(params.runId, params.threadId, params.turnId ?? null, params.method, params.eventJson, isoNow());
+    }
+    listThreadEvents(runId) {
+        const rows = this.connection
+            .prepare("SELECT * FROM run_thread_events WHERE run_id = ? ORDER BY id")
+            .all(runId);
+        return rows.map((row) => ({
+            id: Number(row.id),
+            runId: Number(row.run_id),
+            threadId: String(row.thread_id),
+            ...(row.turn_id !== null ? { turnId: String(row.turn_id) } : {}),
+            method: String(row.method),
+            eventJson: String(row.event_json),
+            createdAt: String(row.created_at),
+        }));
+    }
+}

package/dist/db/webhook-event-store.js

@@ -0,0 +1,71 @@
+export class WebhookEventStore {
+    connection;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    insertWebhookEvent(webhookId, receivedAt) {
+        const existing = this.connection
+            .prepare("SELECT id FROM webhook_events WHERE webhook_id = ?")
+            .get(webhookId);
+        if (existing) {
+            return { id: existing.id, duplicate: true };
+        }
+        const result = this.connection
+            .prepare("INSERT INTO webhook_events (webhook_id, received_at, processing_status) VALUES (?, ?, 'processed')")
+            .run(webhookId, receivedAt);
+        return { id: Number(result.lastInsertRowid), duplicate: false };
+    }
+    insertFullWebhookEvent(params) {
+        const existing = this.connection
+            .prepare("SELECT id FROM webhook_events WHERE webhook_id = ?")
+            .get(params.webhookId);
+        if (existing) {
+            return { id: existing.id, dedupeStatus: "duplicate" };
+        }
+        const result = this.connection
+            .prepare("INSERT INTO webhook_events (webhook_id, received_at, payload_json) VALUES (?, ?, ?)")
+            .run(params.webhookId, params.receivedAt, params.payloadJson);
+        return { id: Number(result.lastInsertRowid), dedupeStatus: "accepted" };
+    }
+    getWebhookPayload(id) {
+        const row = this.connection.prepare("SELECT webhook_id, payload_json FROM webhook_events WHERE id = ?").get(id);
+        if (!row || !row.payload_json)
+            return undefined;
+        return { webhookId: String(row.webhook_id), payloadJson: String(row.payload_json) };
+    }
+    isWebhookDuplicate(webhookId) {
+        return this.connection.prepare("SELECT 1 FROM webhook_events WHERE webhook_id = ?").get(webhookId) !== undefined;
+    }
+    markWebhookProcessed(id, status) {
+        this.connection.prepare("UPDATE webhook_events SET processing_status = ? WHERE id = ?").run(status, id);
+    }
+    assignWebhookProject(id, projectId) {
+        this.connection.prepare("UPDATE webhook_events SET project_id = ? WHERE id = ?").run(projectId, id);
+    }
+    findLatestAgentSessionIdForIssue(linearIssueId) {
+        const row = this.connection.prepare(`
+      SELECT COALESCE(
+        json_extract(payload_json, '$.agentSession.id'),
+        json_extract(payload_json, '$.data.agentSession.id'),
+        json_extract(payload_json, '$.agentSessionId'),
+        json_extract(payload_json, '$.data.agentSessionId')
+      ) AS agent_session_id
+      FROM webhook_events
+      WHERE COALESCE(
+        json_extract(payload_json, '$.agentSession.issueId'),
+        json_extract(payload_json, '$.data.agentSession.issueId'),
+        json_extract(payload_json, '$.agentSession.issue.id'),
+        json_extract(payload_json, '$.data.agentSession.issue.id')
+      ) = ?
+        AND COALESCE(
+          json_extract(payload_json, '$.agentSession.id'),
+          json_extract(payload_json, '$.data.agentSession.id'),
+          json_extract(payload_json, '$.agentSessionId'),
+          json_extract(payload_json, '$.data.agentSessionId')
+        ) IS NOT NULL
+      ORDER BY id DESC
+      LIMIT 1
+    `).get(linearIssueId);
+        return row?.agent_session_id != null ? String(row.agent_session_id) : undefined;
+    }
+}