patchrelay 0.75.0 → 0.75.2

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.75.0",
-  "commit": "ad9b09da1d53",
-  "builtAt": "2026-05-29T13:21:05.647Z"
+  "version": "0.75.2",
+  "commit": "ba00b4a18609",
+  "builtAt": "2026-06-05T23:03:05.291Z"
 }

package/dist/cli/args.js

@@ -11,6 +11,7 @@ export const KNOWN_COMMANDS = new Set([
     "repos",
     "linear",
     "repo",
+    "maintenance",
     "dashboard",
     "dash",
     "d",
@@ -120,7 +121,9 @@ export function assertKnownFlags(parsed, command, allowedFlags) {
                 ? "issue"
                 : command === "service"
                     ? "service"
-                    : "root");
+                    : command === "maintenance"
+                        ? "maintenance"
+                        : "root");
 }
 export function parsePositiveIntegerFlag(value, flagName) {
     if (typeof value !== "string") {

package/dist/cli/cluster-health/index.js

@@ -1,6 +1,6 @@
 import { hasOpenPr } from "../../pr-state.js";
 import { collectActiveOverlapFindings } from "./active-overlap.js";
-import { evaluateLocalIssueHealth, isResolvedDependency, needsReviewAutomation, } from "./local-issue-health.js";
+import { evaluateLocalIssueHealth, evaluateTerminalIssueHealth, isActiveWorkflowIssue, isTerminalFailureIssue, isResolvedDependency, needsReviewAutomation, } from "./local-issue-health.js";
 import { evaluateGitHubIssueHealth } from "./github-issue-health.js";
 import { collectReviewQuillAttemptOwners, } from "./review-quill-probe.js";
 import { probeOptionalService, probePatchRelayService, } from "./service-probe.js";
@@ -10,7 +10,8 @@ export async function collectClusterHealth(config, db, runCommand) {
     const ciEntries = [];
     const now = Date.now();
     const issues = db.listIssues();
-    const openIssues = issues.filter((issue) => issue.factoryState !== "done");
+    const activeWorkflowIssues = issues.filter((issue) => isActiveWorkflowIssue(issue));
+    const historicalTerminalIssues = issues.filter((issue) => isTerminalFailureIssue(issue));
     const trackedByKey = new Map(issues
         .filter((issue) => issue.issueKey)
         .map((issue) => [issue.issueKey, issue]));
@@ -21,7 +22,7 @@ export async function collectClusterHealth(config, db, runCommand) {
         scope: "service:patchrelay",
         message: patchRelayProbe.message,
     });
-    const snapshots = openIssues.map((issue) => {
+    const snapshots = activeWorkflowIssues.map((issue) => {
         const tracked = db.getTrackedIssue(issue.projectId, issue.linearIssueId);
         const deps = db.issues.listIssueDependencies(issue.projectId, issue.linearIssueId);
         const blockedBy = deps.filter((dep) => !isResolvedDependency(dep));
@@ -99,6 +100,17 @@ export async function collectClusterHealth(config, db, runCommand) {
             });
         }
     }
+    for (const issue of historicalTerminalIssues) {
+        const finding = evaluateTerminalIssueHealth(issue);
+        if (finding) {
+            checks.push({
+                ...finding,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                projectId: issue.projectId,
+                ...(issue.prNumber !== undefined ? { prNumber: issue.prNumber } : {}),
+            });
+        }
+    }
     checks.push(...await collectActiveOverlapFindings(snapshots, runCommand));
     for (const snapshot of snapshots) {
         if (!hasOpenPr(snapshot.issue.prNumber, snapshot.issue.prState)) {
@@ -118,18 +130,18 @@ export async function collectClusterHealth(config, db, runCommand) {
         }
     }
     const workflowFailures = checks.filter((check) => check.scope.startsWith("issue:") || check.scope.startsWith("github:"));
-    if (workflowFailures.every((check) => check.status === "pass" || check.status === "warn") && openIssues.length > 0) {
+    if (workflowFailures.every((check) => check.status === "pass" || check.status === "warn") && activeWorkflowIssues.length > 0) {
         checks.push({
             status: "pass",
             scope: "workflow",
-            message: `All ${openIssues.length} non-done issues currently have active work, a tracked blocker, or a downstream owner`,
+            message: `All ${activeWorkflowIssues.length} active workflow issues currently have active work, a tracked blocker, or a downstream owner`,
         });
     }
-    if (openIssues.length === 0) {
+    if (activeWorkflowIssues.length === 0) {
         checks.push({
             status: "pass",
             scope: "workflow",
-            message: "No non-done issues are currently tracked",
+            message: "No active workflow issues are currently tracked",
         });
     }
     if (ciEntries.length > 0) {
@@ -144,8 +156,8 @@ export async function collectClusterHealth(config, db, runCommand) {
     }
     const summary = {
         trackedIssues: issues.length,
-        openIssues: openIssues.length,
-        activeRuns: openIssues.filter((issue) => issue.activeRunId !== undefined).length,
+        openIssues: activeWorkflowIssues.length,
+        activeRuns: activeWorkflowIssues.filter((issue) => issue.activeRunId !== undefined).length,
         blockedIssues: snapshots.filter((snapshot) => snapshot.blockedBy.length > 0).length,
         readyIssues: snapshots.filter((snapshot) => snapshot.readyForExecution).length,
         ciTrackedPrs: ciEntries.length,

package/dist/cli/cluster-health/local-issue-health.js

@@ -13,21 +13,30 @@ export function isResolvedDependency(dep) {
         || state === "cancelled";
 }
 export function needsReviewAutomation(issue) {
-    if (issue.factoryState === "awaiting_queue" || issue.factoryState === "done") {
+    if (issue.factoryState === "awaiting_queue" || !isActiveWorkflowIssue(issue)) {
         return false;
     }
     return hasOpenPr(issue.prNumber, issue.prState);
 }
-export function evaluateLocalIssueHealth(snapshot) {
-    const { issue, session, missingTrackedBlockers, blockedBy, ageMs, readyForExecution } = snapshot;
-    const pausedNoPrWork = isUndelegatedPausedNoPrWork(issue);
+export function isActiveWorkflowIssue(issue) {
+    return issue.factoryState !== "done" && !isTerminalFailureIssue(issue);
+}
+export function isTerminalFailureIssue(issue) {
+    return issue.factoryState === "failed" || issue.factoryState === "escalated";
+}
+export function evaluateTerminalIssueHealth(issue) {
     if (issue.factoryState === "failed" || issue.factoryState === "escalated") {
         return {
-            status: "fail",
+            status: "warn",
             scope: "issue:terminal",
-            message: `Issue is in terminal failure state ${issue.factoryState}`,
+            message: `Historical terminal issue is in failure state ${issue.factoryState}`,
         };
     }
+    return undefined;
+}
+export function evaluateLocalIssueHealth(snapshot) {
+    const { issue, session, missingTrackedBlockers, blockedBy, ageMs, readyForExecution } = snapshot;
+    const pausedNoPrWork = isUndelegatedPausedNoPrWork(issue);
     if (missingTrackedBlockers.length > 0) {
         return {
             status: "fail",

package/dist/cli/commands/maintenance.js

@@ -0,0 +1,55 @@
+import { runWebhookEventRetention } from "../../event-retention.js";
+import { CliUsageError } from "../errors.js";
+import { formatJson } from "../formatters/json.js";
+import { writeOutput } from "../output.js";
+export async function handleMaintenanceCommand(params) {
+    const [subcommand] = params.commandArgs;
+    if (subcommand !== "prune-events") {
+        throw new CliUsageError(`Unknown maintenance command: ${subcommand ?? ""}`.trim(), "maintenance");
+    }
+    const retentionDays = readPositiveIntegerFlag(params.parsed, "retention-days");
+    const batchSize = readPositiveIntegerFlag(params.parsed, "batch-size");
+    const archive = params.parsed.flags.get("archive") === true;
+    const discard = params.parsed.flags.get("discard") === true;
+    if (archive && discard) {
+        throw new CliUsageError("Use either --archive or --discard, not both", "maintenance");
+    }
+    const result = await runWebhookEventRetention({
+        db: params.data.db,
+        config: params.config,
+        options: {
+            dryRun: params.parsed.flags.get("dry-run") === true,
+            ...(retentionDays !== undefined ? { retentionDays } : {}),
+            ...(batchSize !== undefined ? { batchSize } : {}),
+            ...(archive ? { archiveOldEvents: true } : {}),
+            ...(discard ? { archiveOldEvents: false } : {}),
+        },
+    });
+    if (params.json) {
+        writeOutput(params.stdout, formatJson(result));
+        return 0;
+    }
+    writeOutput(params.stdout, [
+        `Cutoff: ${result.cutoffIso}`,
+        `Scanned: ${result.scanned}`,
+        `Archived: ${result.archived}`,
+        `Deleted: ${result.deleted}`,
+        `Remaining: ${result.remaining}`,
+        result.archiveFile ? `Archive: ${result.archiveFile}` : undefined,
+        result.dryRun ? "Dry run: yes" : undefined,
+    ].filter(Boolean).join("\n") + "\n");
+    return 0;
+}
+function readPositiveIntegerFlag(parsed, flag) {
+    const value = parsed.flags.get(flag);
+    if (value === undefined || value === false)
+        return undefined;
+    if (value === true) {
+        throw new CliUsageError(`--${flag} requires a value`, "maintenance");
+    }
+    const parsedValue = Number(value);
+    if (!Number.isInteger(parsedValue) || parsedValue <= 0) {
+        throw new CliUsageError(`--${flag} must be a positive integer`, "maintenance");
+    }
+    return parsedValue;
+}

package/dist/cli/help.js

@@ -45,6 +45,8 @@ export function rootHelpText() {
         "  service status [--json]                                 Show systemd state and local health",
         "  service codex-status [--json]                           Show Codex account and usage snapshot from this service",
         "  cluster [--json]                                        Check service + workflow health across all tracked issues",
+        "  maintenance prune-events [--dry-run] [--archive|--discard] [--retention-days <days>] [--json]",
+        "                                                          Prune or archive old processed webhook events",
         "  service logs [--lines <count>] [--json]                 Show recent service logs",
         "  serve                                                   Run the local PatchRelay service",
         "",
@@ -79,6 +81,7 @@ export function rootHelpText() {
         "  patchrelay help issue",
         "  patchrelay help service",
         "  patchrelay help cluster",
+        "  patchrelay help maintenance",
     ].join("\n");
 }
 export function linearHelpText() {
@@ -204,10 +207,35 @@ export function clusterHelpText() {
         "  patchrelay cluster --json",
     ].join("\n");
 }
+export function maintenanceHelpText() {
+    return [
+        "Usage:",
+        "  patchrelay maintenance prune-events [options]",
+        "",
+        "Options:",
+        "  --dry-run                    Count archiveable events without deleting",
+        "  --archive                    Write old events to cold JSONL gzip storage before deleting",
+        "  --discard                    Delete old events without archiving",
+        "  --retention-days <days>      Override configured retention window (default 7)",
+        "  --batch-size <count>         Override maintenance batch size",
+        "  --json                       Emit structured JSON output",
+        "  --help, -h                   Show this help",
+        "",
+        "Behavior:",
+        "  Only processed webhook events older than the retention cutoff are touched.",
+        "  Pending/unprocessed webhook events are never pruned.",
+        "",
+        "Examples:",
+        "  patchrelay maintenance prune-events --dry-run",
+        "  patchrelay maintenance prune-events --archive",
+    ].join("\n");
+}
 export function helpTextFor(topic) {
     switch (topic) {
         case "cluster":
             return clusterHelpText();
+        case "maintenance":
+            return maintenanceHelpText();
         case "linear":
             return linearHelpText();
         case "repo":

package/dist/cli/index.js

@@ -6,6 +6,7 @@ import { handleClusterCommand } from "./commands/cluster.js";
 import { handleLinearCommand } from "./commands/linear.js";
 import { handleSequenceCheckCommand } from "./commands/sequence-check.js";
 import { handleRepoCommand } from "./commands/repo.js";
+import { handleMaintenanceCommand } from "./commands/maintenance.js";
 import { handleInitCommand, handleServiceCommand } from "./commands/setup.js";
 import { CliUsageError } from "./errors.js";
 import { formatJson } from "./formatters/json.js";
@@ -25,6 +26,7 @@ function getCommandConfigProfile(command) {
         case "cluster":
         case "repo":
         case "issue":
+        case "maintenance":
         case "sequence-check":
             return "cli";
         default:
@@ -89,6 +91,13 @@ function validateFlags(command, commandArgs, parsed) {
         case "cluster":
             assertKnownFlags(parsed, command, ["json"]);
             return;
+        case "maintenance":
+            if (commandArgs[0] === "prune-events") {
+                assertKnownFlags(parsed, command, ["json", "dry-run", "archive", "discard", "retention-days", "batch-size"]);
+                return;
+            }
+            assertKnownFlags(parsed, command, []);
+            return;
         case "sequence-check":
             assertKnownFlags(parsed, command, ["json", "base"]);
             return;
@@ -185,7 +194,7 @@ export async function runCli(argv, options) {
     const json = parsed.flags.get("json") === true;
     if (command === "help") {
         const topic = commandArgs[0];
-        if (topic === "linear" || topic === "repo" || topic === "issue" || topic === "service" || topic === "cluster") {
+        if (topic === "linear" || topic === "repo" || topic === "issue" || topic === "service" || topic === "cluster" || topic === "maintenance") {
             writeOutput(stdout, `${helpTextFor(topic)}\n`);
             return 0;
         }
@@ -206,7 +215,7 @@ export async function runCli(argv, options) {
             ? "linear"
             : command === "repo"
                 ? "repo"
-                : command === "issue" || command === "service" || command === "cluster"
+                : command === "issue" || command === "service" || command === "cluster" || command === "maintenance"
                     ? command
                     : "root";
         writeOutput(stdout, `${helpTextFor(helpTopic)}\n`);
@@ -354,6 +363,21 @@ export async function runCli(argv, options) {
                 runCommand,
             });
         }
+        if (command === "maintenance") {
+            const issueData = await ensureIssueDataAccess(data, config);
+            if (!data) {
+                data = issueData;
+                ownsData = true;
+            }
+            return await handleMaintenanceCommand({
+                commandArgs,
+                parsed,
+                json,
+                stdout,
+                data: issueData,
+                config,
+            });
+        }
         if (command === "dashboard") {
             const { handleWatchCommand } = await import("./commands/watch.js");
             return await handleWatchCommand({ config, parsed });

package/dist/cli/output.js

@@ -34,7 +34,7 @@ export function formatClusterHealth(report) {
         lines.push(`${marker} [${detail}] ${check.message}`);
     }
     lines.push("");
-    lines.push(`Summary: tracked=${report.summary.trackedIssues} non_done=${report.summary.openIssues} active_runs=${report.summary.activeRuns} blocked=${report.summary.blockedIssues} ready=${report.summary.readyIssues}`);
+    lines.push(`Summary: tracked=${report.summary.trackedIssues} active=${report.summary.openIssues} active_runs=${report.summary.activeRuns} blocked=${report.summary.blockedIssues} ready=${report.summary.readyIssues}`);
     if (report.summary.ciTrackedPrs > 0) {
         lines.push(`CI summary: prs=${report.summary.ciTrackedPrs} pending=${report.summary.ciPending} success=${report.summary.ciSuccess} failure=${report.summary.ciFailure} unknown=${report.summary.ciUnknown} missing_owner=${report.summary.ciOrphaned}`);
         for (const entry of report.ci) {

package/dist/codex-app-server.js

@@ -23,6 +23,7 @@ const FOLLOWUP_INTENT_DEVELOPER_INSTRUCTIONS = [
     "Use only the text and state facts in the current prompt.",
     "Return only the requested JSON object.",
 ].join("\n");
+const MAX_STDOUT_MESSAGES_PER_DRAIN = 100;
 export function resolveCodexAppServerLaunch(config) {
     if (!config.sourceBashrc) {
         return {
@@ -50,6 +51,7 @@ export class CodexAppServerClient extends EventEmitter {
     nextRequestId = 1;
     pending = new Map();
     stdoutBuffer = "";
+    drainScheduled = false;
     started = false;
     stopping = false;
     startPromise;
@@ -360,6 +362,7 @@ export class CodexAppServerClient extends EventEmitter {
             this.started = false;
             this.child = undefined;
             this.stdoutBuffer = "";
+            this.drainScheduled = false;
             const log = this.stopping ? this.logger.info.bind(this.logger) : this.logger.warn.bind(this.logger);
             log({
                 code: code ?? 1,
@@ -374,11 +377,12 @@ export class CodexAppServerClient extends EventEmitter {
             if (this.stdoutBuffer.length > 50 * 1024 * 1024) {
                 this.logger.error({ bufferSize: this.stdoutBuffer.length }, "Codex app-server stdout buffer exceeded 50 MB — killing process");
                 this.stdoutBuffer = "";
+                this.drainScheduled = false;
                 this.rejectAllPending(new Error("Codex app-server stdout buffer overflow"));
                 this.child?.kill("SIGTERM");
                 return;
             }
-            this.drainMessages();
+            this.scheduleDrainMessages();
         });
         const initializeResponse = await this.sendRequest("initialize", {
             clientInfo: {
@@ -438,6 +442,7 @@ export class CodexAppServerClient extends EventEmitter {
         this.started = false;
         this.child = undefined;
         this.stdoutBuffer = "";
+        this.drainScheduled = false;
         this.logger.error({
             error: sanitizeDiagnosticText(error.message),
             pendingRequestCount: this.pending.size,
@@ -446,7 +451,8 @@ export class CodexAppServerClient extends EventEmitter {
         child?.kill("SIGTERM");
     }
     drainMessages() {
-        while (true) {
+        let processed = 0;
+        while (processed < MAX_STDOUT_MESSAGES_PER_DRAIN) {
             const newlineIndex = this.stdoutBuffer.indexOf("\n");
             if (newlineIndex === -1) {
                 return;
@@ -458,6 +464,7 @@ export class CodexAppServerClient extends EventEmitter {
             }
             try {
                 this.handleMessage(JSON.parse(line));
+                processed += 1;
             }
             catch (error) {
                 const err = error instanceof Error ? error : new Error(String(error));
@@ -471,6 +478,19 @@ export class CodexAppServerClient extends EventEmitter {
                 return;
             }
         }
+        if (this.stdoutBuffer.includes("\n")) {
+            this.scheduleDrainMessages();
+        }
+    }
+    scheduleDrainMessages() {
+        if (this.drainScheduled) {
+            return;
+        }
+        this.drainScheduled = true;
+        setImmediate(() => {
+            this.drainScheduled = false;
+            this.drainMessages();
+        });
     }
     handleMessage(message) {
         if ("method" in message && "id" in message) {

package/dist/config.js

@@ -131,6 +131,9 @@ const configSchema = z.object({
     database: z.object({
         path: z.string().min(1).default(getDefaultDatabasePath()),
         wal: z.boolean().default(true),
+        event_retention_days: z.number().int().positive().default(7),
+        archive_old_events: z.boolean().default(false),
+        archive_path: z.string().min(1).optional(),
     }),
     linear: z.object({
         webhook_secret_env: z.string().default("LINEAR_WEBHOOK_SECRET"),
@@ -555,6 +558,9 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
         database: {
             path: ensureAbsolutePath(env.PATCHRELAY_DB_PATH ?? parsed.database.path),
             wal: parsed.database.wal,
+            eventRetentionDays: parsed.database.event_retention_days,
+            archiveOldEvents: parsed.database.archive_old_events,
+            archivePath: ensureAbsolutePath(parsed.database.archive_path ?? path.join(path.dirname(env.PATCHRELAY_DB_PATH ?? parsed.database.path), "archive")),
         },
         linear: {
             webhookSecret: webhookSecret ?? "",

package/dist/db/migrations.js

@@ -49,6 +49,7 @@ CREATE TABLE IF NOT EXISTS runs (
   linear_issue_id TEXT NOT NULL,
   run_type TEXT NOT NULL DEFAULT 'implementation',
   status TEXT NOT NULL,
+  launch_phase TEXT,
   source_head_sha TEXT,
   prompt_text TEXT,
   thread_id TEXT,
@@ -248,6 +249,7 @@ CREATE INDEX IF NOT EXISTS idx_issue_sessions_key ON issue_sessions(issue_key);
 CREATE INDEX IF NOT EXISTS idx_issue_sessions_lease ON issue_sessions(leased_until, session_state);
 CREATE INDEX IF NOT EXISTS idx_issue_session_events_issue ON issue_session_events(project_id, linear_issue_id, id);
 CREATE INDEX IF NOT EXISTS idx_issue_session_events_pending ON issue_session_events(processed_at, project_id, linear_issue_id, id);
+CREATE INDEX IF NOT EXISTS idx_webhook_events_retention ON webhook_events(processing_status, received_at, id);
 CREATE INDEX IF NOT EXISTS idx_run_thread_events_run ON run_thread_events(run_id, id);
 CREATE INDEX IF NOT EXISTS idx_operator_feed_events_issue ON operator_feed_events(issue_key, id);
 CREATE INDEX IF NOT EXISTS idx_operator_feed_events_project ON operator_feed_events(project_id, id);
@@ -295,6 +297,7 @@ export function runPatchRelayMigrations(connection) {
     WHERE display_updated_at IS NULL
   `).run();
     addColumnIfMissing(connection, "runs", "source_head_sha", "TEXT");
+    addColumnIfMissing(connection, "runs", "launch_phase", "TEXT");
     addColumnIfMissing(connection, "runs", "completion_check_thread_id", "TEXT");
     addColumnIfMissing(connection, "runs", "completion_check_turn_id", "TEXT");
     addColumnIfMissing(connection, "runs", "completion_check_outcome", "TEXT");

package/dist/db/run-store.js

@@ -20,8 +20,8 @@ export class RunStore {
     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', ?, ?, ?)
+      INSERT INTO runs (issue_id, project_id, linear_issue_id, run_type, status, launch_phase, source_head_sha, prompt_text, started_at)
+      VALUES (?, ?, ?, ?, 'queued', 'claimed', ?, ?, ?)
     `).run(params.issueId, params.projectId, params.linearIssueId, params.runType, params.sourceHeadSha ?? null, params.promptText ?? null, now);
         const run = this.getRunById(Number(result.lastInsertRowid));
         const issue = this.issues.getIssue(params.projectId, params.linearIssueId);
@@ -76,7 +76,8 @@ export class RunStore {
         thread_id = ?,
         parent_thread_id = COALESCE(?, parent_thread_id),
         turn_id = COALESCE(?, turn_id),
-        status = 'running'
+        status = 'running',
+        launch_phase = 'running'
       WHERE id = ?
         AND ended_at IS NULL
         AND status IN ('queued', 'running')
@@ -100,6 +101,15 @@ export class RunStore {
     updateRunTurnId(runId, turnId) {
         this.connection.prepare("UPDATE runs SET turn_id = ? WHERE id = ?").run(turnId, runId);
     }
+    updateLaunchPhase(runId, launchPhase) {
+        this.connection.prepare(`
+      UPDATE runs
+      SET launch_phase = ?
+      WHERE id = ?
+        AND ended_at IS NULL
+        AND status IN ('queued', 'running')
+    `).run(launchPhase, runId);
+    }
     finishRun(runId, params) {
         const now = isoNow();
         this.connection.prepare(`

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

@@ -42,6 +42,46 @@ export class WebhookEventStore {
     assignWebhookProject(id, projectId) {
         this.connection.prepare("UPDATE webhook_events SET project_id = ? WHERE id = ?").run(projectId, id);
     }
+    listArchiveableEventsBefore(cutoffIso, limit) {
+        const rows = this.connection.prepare(`
+      SELECT id, webhook_id, received_at, project_id, payload_json, processing_status
+      FROM webhook_events
+      WHERE received_at < ?
+        AND processing_status != 'pending'
+      ORDER BY received_at ASC, id ASC
+      LIMIT ?
+    `).all(cutoffIso, limit);
+        return rows.map((row) => ({
+            id: Number(row.id),
+            webhookId: String(row.webhook_id),
+            receivedAt: String(row.received_at),
+            ...(row.project_id != null ? { projectId: String(row.project_id) } : {}),
+            ...(row.payload_json != null ? { payloadJson: String(row.payload_json) } : {}),
+            processingStatus: String(row.processing_status),
+        }));
+    }
+    countArchiveableEventsBefore(cutoffIso) {
+        const row = this.connection.prepare(`
+      SELECT COUNT(*) AS count
+      FROM webhook_events
+      WHERE received_at < ?
+        AND processing_status != 'pending'
+    `).get(cutoffIso);
+        return Number(row?.count ?? 0);
+    }
+    deleteWebhookEventsByIds(ids) {
+        if (ids.length === 0)
+            return 0;
+        return this.connection.transaction(() => {
+            let deleted = 0;
+            const statement = this.connection.prepare("DELETE FROM webhook_events WHERE id = ?");
+            for (const id of ids) {
+                const result = statement.run(id);
+                deleted += Number(result.changes ?? 0);
+            }
+            return deleted;
+        })();
+    }
     findLatestAgentSessionIdForIssue(linearIssueId) {
         const row = this.connection.prepare(`
       SELECT COALESCE(

package/dist/db.js

@@ -16,6 +16,7 @@ import { TrackedIssueQuery } from "./tracked-issue-query.js";
 import { WorkflowWakeResolver } from "./workflow-wake-resolver.js";
 export class PatchRelayDatabase {
     connection;
+    issueSessionProjection;
     telemetry = noopTelemetry;
     telemetryProxy = {
         emit: (event) => this.telemetry.emit(event),
@@ -38,12 +39,13 @@ export class PatchRelayDatabase {
         this.connection.pragma("foreign_keys = ON");
         if (wal) {
             this.connection.pragma("journal_mode = WAL");
+            this.connection.pragma("synchronous = NORMAL");
         }
         this.linearInstallations = new LinearInstallationStore(this.connection);
         this.operatorFeed = new OperatorFeedStore(this.connection);
         this.repositories = new RepositoryLinkStore(this.connection);
         this.webhookEvents = new WebhookEventStore(this.connection);
-        const issueSessionProjection = new ImmediateIssueSessionProjectionInvalidator({
+        this.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),
@@ -58,9 +60,9 @@ export class PatchRelayDatabase {
             }),
             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.issues = new IssueStore(this.connection, this.issueSessionProjection);
+        this.runs = new RunStore(this.connection, mapRunRow, this.issues, this.issueSessionProjection, this.telemetryProxy);
+        this.issueSessions = new IssueSessionStore(this.connection, mapIssueSessionRow, mapIssueSessionEventRow, this.issues, this.runs, this.issueSessionProjection, this.telemetryProxy);
         this.workflowWakes = new WorkflowWakeResolver(this.issues, this.issueSessions);
         this.trackedIssues = new TrackedIssueQuery(this.issues, this.issueSessions, this.workflowWakes, this.runs);
     }
@@ -78,6 +80,12 @@ export class PatchRelayDatabase {
     transaction(fn) {
         return this.connection.transaction(fn)();
     }
+    batchIssueSessionProjections(fn) {
+        return this.issueSessionProjection.batch(fn);
+    }
+    runWalCheckpoint(mode = "PASSIVE") {
+        return this.connection.prepare(`PRAGMA wal_checkpoint(${mode})`).all();
+    }
     close() {
         this.connection.close();
     }
@@ -248,6 +256,7 @@ function mapRunRow(row) {
         linearIssueId: String(row.linear_issue_id),
         runType: String(row.run_type ?? "implementation"),
         status: String(row.status),
+        ...(row.launch_phase !== null && row.launch_phase !== undefined ? { launchPhase: String(row.launch_phase) } : {}),
         ...(row.source_head_sha !== null ? { sourceHeadSha: String(row.source_head_sha) } : {}),
         ...(row.prompt_text !== null ? { promptText: String(row.prompt_text) } : {}),
         ...(row.thread_id !== null ? { threadId: String(row.thread_id) } : {}),