patchrelay 0.75.1 → 0.75.3

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.75.1",
-  "commit": "3f8fb3c35611",
-  "builtAt": "2026-06-05T20:39:12.061Z"
+  "version": "0.75.3",
+  "commit": "0186011684f3",
+  "builtAt": "2026-06-09T00:09:44.822Z"
 }

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/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/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/issue-store.js

@@ -92,6 +92,26 @@ export class IssueStore {
             .all();
         return rows.map(mapIssueRow);
     }
+    // Recovery net for a dangling active slot: an issue whose
+    // `active_run_id` still points at a run that has already reached a
+    // terminal status. This happens when the post-run finalize never ran
+    // to completion — almost always a service restart landing between
+    // `finishRun` (which marks the run terminal) and the issue write that
+    // clears `active_run_id` and arms the next wake. The Codex
+    // `turn/completed` notification that would finalize it never re-fires
+    // after restart, and every idle/recovery pass gates on
+    // `active_run_id IS NULL`, so the issue is invisible to all of them
+    // and freezes indefinitely. The orchestrator clears the slot so the
+    // idle reconciler can route the issue forward (review_fix, etc.).
+    listIssuesWithTerminalActiveRun() {
+        const rows = this.connection
+            .prepare(`SELECT i.* FROM issues i
+         JOIN runs r ON r.id = i.active_run_id
+         WHERE i.active_run_id IS NOT NULL
+         AND r.status IN ('completed', 'failed', 'released', 'superseded')`)
+            .all();
+        return rows.map(mapIssueRow);
+    }
     // Safety net for orphaned wakes: any delegated, non-terminal issue
     // with at least one unprocessed session event but no active run.
     // The orchestrator's enqueueIssue is the only path that drains these

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),
@@ -44,7 +45,7 @@ export class PatchRelayDatabase {
         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),
@@ -59,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);
     }
@@ -79,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();
     }
@@ -249,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) } : {}),

package/dist/event-retention.js

@@ -0,0 +1,100 @@
+import { createWriteStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { once } from "node:events";
+import { createGzip } from "node:zlib";
+export const DEFAULT_EVENT_RETENTION_DAYS = 7;
+const DEFAULT_BATCH_SIZE = 1_000;
+export async function runWebhookEventRetention(params) {
+    const retentionDays = params.options?.retentionDays
+        ?? params.config.database.eventRetentionDays
+        ?? DEFAULT_EVENT_RETENTION_DAYS;
+    const cutoffIso = computeRetentionCutoffIso(params.options?.now ?? new Date(), retentionDays);
+    const batchSize = Math.max(1, Math.floor(params.options?.batchSize ?? DEFAULT_BATCH_SIZE));
+    const archiveOldEvents = params.options?.archiveOldEvents ?? params.config.database.archiveOldEvents === true;
+    const archivePath = params.options?.archivePath ?? params.config.database.archivePath;
+    const dryRun = params.options?.dryRun === true;
+    let scanned = 0;
+    let archived = 0;
+    let deleted = 0;
+    let writer;
+    if (dryRun) {
+        const remaining = params.db.webhookEvents.countArchiveableEventsBefore(cutoffIso);
+        return {
+            cutoffIso,
+            scanned: remaining,
+            archived: 0,
+            deleted: 0,
+            remaining,
+            dryRun,
+        };
+    }
+    try {
+        if (archiveOldEvents) {
+            writer = await JsonlGzipArchiveWriter.create(resolveArchiveFilePath(archivePath, params.options?.now ?? new Date()));
+        }
+        while (true) {
+            const records = params.db.webhookEvents.listArchiveableEventsBefore(cutoffIso, batchSize);
+            if (records.length === 0)
+                break;
+            scanned += records.length;
+            if (writer) {
+                await writer.writeRecords(records);
+                archived += records.length;
+            }
+            deleted += params.db.webhookEvents.deleteWebhookEventsByIds(records.map((record) => record.id));
+            if (records.length < batchSize)
+                break;
+        }
+    }
+    finally {
+        await writer?.close();
+    }
+    const remaining = params.db.webhookEvents.countArchiveableEventsBefore(cutoffIso);
+    return {
+        cutoffIso,
+        scanned,
+        archived,
+        deleted,
+        remaining,
+        ...(writer?.filePath ? { archiveFile: writer.filePath } : {}),
+        dryRun,
+    };
+}
+export function computeRetentionCutoffIso(now, retentionDays) {
+    return new Date(now.getTime() - retentionDays * 24 * 60 * 60 * 1000).toISOString();
+}
+function resolveArchiveFilePath(archivePath, now) {
+    const root = archivePath ?? path.join(process.cwd(), "archive");
+    const stamp = now.toISOString().replaceAll(":", "-").replaceAll(".", "-");
+    return path.join(root, "webhook-events", `${stamp}.jsonl.gz`);
+}
+class JsonlGzipArchiveWriter {
+    filePath;
+    gzip;
+    output;
+    constructor(filePath, gzip, output) {
+        this.filePath = filePath;
+        this.gzip = gzip;
+        this.output = output;
+    }
+    static async create(filePath) {
+        await mkdir(path.dirname(filePath), { recursive: true });
+        const gzip = createGzip();
+        const output = createWriteStream(filePath, { flags: "wx" });
+        gzip.pipe(output);
+        return new JsonlGzipArchiveWriter(filePath, gzip, output);
+    }
+    async writeRecords(records) {
+        for (const record of records) {
+            const line = `${JSON.stringify(record)}\n`;
+            if (!this.gzip.write(line)) {
+                await once(this.gzip, "drain");
+            }
+        }
+    }
+    async close() {
+        this.gzip.end();
+        await once(this.output, "close");
+    }
+}

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

@@ -1,9 +1,23 @@
 import { emitTelemetry, noopTelemetry } from "./telemetry.js";
 export class ImmediateIssueSessionProjectionInvalidator {
     deps;
+    batchDepth = 0;
+    pendingProjections = new Map();
     constructor(deps) {
         this.deps = deps;
     }
+    batch(fn) {
+        this.batchDepth += 1;
+        try {
+            return fn();
+        }
+        finally {
+            this.batchDepth -= 1;
+            if (this.batchDepth === 0) {
+                this.flushPendingProjections();
+            }
+        }
+    }
     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);
@@ -32,12 +46,26 @@ export class ImmediateIssueSessionProjectionInvalidator {
         this.projectIssueById(projectId, linearIssueId, "issue_session_events_changed");
     }
     projectIssueById(projectId, linearIssueId, reason) {
+        if (this.batchDepth > 0) {
+            this.queueProjection({ projectId, linearIssueId, reason });
+            return;
+        }
         const issue = this.deps.getIssue(projectId, linearIssueId);
         if (issue) {
             this.projectIssue(issue, reason);
         }
     }
     projectIssue(issue, reason, options) {
+        if (this.batchDepth > 0) {
+            this.queueProjection({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                issue,
+                reason,
+                ...(options ? { options } : {}),
+            });
+            return;
+        }
         const beforeWaitingReason = this.deps.getIssueSessionWaitingReason?.(issue.projectId, issue.linearIssueId);
         this.deps.projectIssue(issue, options);
         this.emitReprojected(reason, issue);
@@ -87,4 +115,32 @@ export class ImmediateIssueSessionProjectionInvalidator {
             ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
         });
     }
+    queueProjection(projection) {
+        const key = `${projection.projectId}::${projection.linearIssueId}`;
+        const current = this.pendingProjections.get(key);
+        this.pendingProjections.set(key, {
+            projectId: projection.projectId,
+            linearIssueId: projection.linearIssueId,
+            issue: projection.issue ?? current?.issue,
+            reason: projection.reason,
+            options: mergeProjectionOptions(current?.options, projection.options),
+        });
+    }
+    flushPendingProjections() {
+        const pending = Array.from(this.pendingProjections.values());
+        this.pendingProjections.clear();
+        for (const projection of pending) {
+            const issue = projection.issue ?? this.deps.getIssue(projection.projectId, projection.linearIssueId);
+            if (issue) {
+                this.projectIssue(issue, projection.reason, projection.options);
+            }
+        }
+    }
+}
+function mergeProjectionOptions(current, next) {
+    if (!current)
+        return next;
+    if (!next)
+        return current;
+    return { ...current, ...next };
 }

package/dist/run-launcher.js

@@ -104,53 +104,55 @@ export class RunLauncher {
     }
     claimRun(params) {
         return this.db.issueSessions.withIssueSessionLease(params.item.projectId, params.item.issueId, params.leaseId, () => {
-            const fresh = this.db.issues.getIssue(params.item.projectId, params.item.issueId);
-            if (!fresh || fresh.activeRunId !== undefined)
-                return undefined;
-            const wakeIssue = params.materializeLegacyPendingWake(fresh, {
-                projectId: params.item.projectId,
-                linearIssueId: params.item.issueId,
-                leaseId: params.leaseId,
-            });
-            const freshWake = params.resolveRunWake(wakeIssue);
-            if (!freshWake || freshWake.runType !== params.runType)
-                return undefined;
-            const created = this.db.runs.createRun({
-                issueId: fresh.id,
-                projectId: params.item.projectId,
-                linearIssueId: params.item.issueId,
-                runType: params.runType,
-                ...(params.sourceHeadSha ? { sourceHeadSha: params.sourceHeadSha } : {}),
-                promptText: params.prompt,
-            });
-            const failureHeadSha = typeof params.effectiveContext?.failureHeadSha === "string"
-                ? params.effectiveContext.failureHeadSha
-                : typeof params.effectiveContext?.headSha === "string" ? params.effectiveContext.headSha : undefined;
-            const failureSignature = typeof params.effectiveContext?.failureSignature === "string" ? params.effectiveContext.failureSignature : undefined;
-            this.db.issues.upsertIssue({
-                projectId: params.item.projectId,
-                linearIssueId: params.item.issueId,
-                pendingRunType: null,
-                pendingRunContextJson: null,
-                activeRunId: created.id,
-                branchName: params.branchName,
-                worktreePath: params.worktreePath,
-                factoryState: params.runType === "implementation" ? "implementing"
-                    : params.runType === "ci_repair" ? "repairing_ci"
-                        : params.runType === "review_fix" || params.runType === "branch_upkeep" ? "changes_requested"
-                            : params.runType === "queue_repair" ? "repairing_queue"
-                                : "implementing",
-                ...((params.runType === "ci_repair" || params.runType === "queue_repair") && failureSignature
-                    ? {
-                        lastAttemptedFailureSignature: failureSignature,
-                        lastAttemptedFailureHeadSha: failureHeadSha ?? null,
-                        lastAttemptedFailureAt: new Date().toISOString(),
-                    }
-                    : {}),
+            return this.db.batchIssueSessionProjections(() => {
+                const fresh = this.db.issues.getIssue(params.item.projectId, params.item.issueId);
+                if (!fresh || fresh.activeRunId !== undefined)
+                    return undefined;
+                const wakeIssue = params.materializeLegacyPendingWake(fresh, {
+                    projectId: params.item.projectId,
+                    linearIssueId: params.item.issueId,
+                    leaseId: params.leaseId,
+                });
+                const freshWake = params.resolveRunWake(wakeIssue);
+                if (!freshWake || freshWake.runType !== params.runType)
+                    return undefined;
+                const created = this.db.runs.createRun({
+                    issueId: fresh.id,
+                    projectId: params.item.projectId,
+                    linearIssueId: params.item.issueId,
+                    runType: params.runType,
+                    ...(params.sourceHeadSha ? { sourceHeadSha: params.sourceHeadSha } : {}),
+                    promptText: params.prompt,
+                });
+                const failureHeadSha = typeof params.effectiveContext?.failureHeadSha === "string"
+                    ? params.effectiveContext.failureHeadSha
+                    : typeof params.effectiveContext?.headSha === "string" ? params.effectiveContext.headSha : undefined;
+                const failureSignature = typeof params.effectiveContext?.failureSignature === "string" ? params.effectiveContext.failureSignature : undefined;
+                this.db.issues.upsertIssue({
+                    projectId: params.item.projectId,
+                    linearIssueId: params.item.issueId,
+                    pendingRunType: null,
+                    pendingRunContextJson: null,
+                    activeRunId: created.id,
+                    branchName: params.branchName,
+                    worktreePath: params.worktreePath,
+                    factoryState: params.runType === "implementation" ? "implementing"
+                        : params.runType === "ci_repair" ? "repairing_ci"
+                            : params.runType === "review_fix" || params.runType === "branch_upkeep" ? "changes_requested"
+                                : params.runType === "queue_repair" ? "repairing_queue"
+                                    : "implementing",
+                    ...((params.runType === "ci_repair" || params.runType === "queue_repair") && failureSignature
+                        ? {
+                            lastAttemptedFailureSignature: failureSignature,
+                            lastAttemptedFailureHeadSha: failureHeadSha ?? null,
+                            lastAttemptedFailureAt: new Date().toISOString(),
+                        }
+                        : {}),
+                });
+                this.db.issueSessions.consumeIssueSessionEvents(params.item.projectId, params.item.issueId, freshWake.eventIds, created.id);
+                this.db.issueSessions.setIssueSessionLastWakeReason(params.item.projectId, params.item.issueId, freshWake.wakeReason ?? null);
+                return created;
             });
-            this.db.issueSessions.consumeIssueSessionEvents(params.item.projectId, params.item.issueId, freshWake.eventIds, created.id);
-            this.db.issueSessions.setIssueSessionLastWakeReason(params.item.projectId, params.item.issueId, freshWake.wakeReason ?? null);
-            return created;
         });
     }
     async launchTurn(params) {
@@ -186,6 +188,7 @@ export class RunLauncher {
             if (prepareResult.ran && prepareResult.exitCode !== 0) {
                 throw new Error(`prepare-worktree hook failed (exit ${prepareResult.exitCode}): ${prepareResult.stderr?.slice(0, 500) ?? ""}`);
             }
+            this.db.runs.updateLaunchPhase(params.run.id, "worktree_prepared");
             params.assertLaunchLease(params.run, "before starting the Codex turn");
             const compactThread = shouldCompactThread(params.issue, params.issueSession?.threadGeneration, params.effectiveContext);
             if (compactThread && params.issue.threadId) {
@@ -200,9 +203,11 @@ export class RunLauncher {
                 createdThreadForRun = true;
                 this.db.issueSessions.upsertIssueWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, threadId });
             }
+            this.db.runs.updateLaunchPhase(params.run.id, "thread_started");
             try {
                 const turn = await this.codex.startTurn({ threadId, cwd: params.worktreePath, input: params.prompt });
                 turnId = turn.turnId;
+                this.db.runs.updateLaunchPhase(params.run.id, "turn_started");
             }
             catch (turnError) {
                 const msg = turnError instanceof Error ? turnError.message : String(turnError);
@@ -214,6 +219,7 @@ export class RunLauncher {
                     this.db.issueSessions.upsertIssueWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, threadId });
                     const turn = await this.codex.startTurn({ threadId, cwd: params.worktreePath, input: params.prompt });
                     turnId = turn.turnId;
+                    this.db.runs.updateLaunchPhase(params.run.id, "turn_started");
                 }
                 else {
                     throw turnError;

package/dist/run-orchestrator.js

@@ -26,6 +26,10 @@ import { CodexThreadMaterializingError, isThreadMaterializingError } from "./cod
 import { emitTelemetry, noopTelemetry } from "./telemetry.js";
 import { LinearIssueProjectionService } from "./linear-issue-projection.js";
 import { RunAdmissionController } from "./run-admission-controller.js";
+// A terminal run must hold the active slot for at least this long before
+// the orchestrator force-clears it, so we never race the normal
+// notification-driven finalize that runs within seconds of completion.
+const DANGLING_ACTIVE_RUN_MIN_AGE_MS = 2 * 60_000;
 function lowerCaseFirst(value) {
     return value ? `${value.slice(0, 1).toLowerCase()}${value.slice(1)}` : value;
 }
@@ -559,6 +563,10 @@ export class RunOrchestrator {
         for (const run of this.db.runs.listRunningRuns()) {
             await this.reconcileRun(run);
         }
+        // Free any issue whose active slot is pinned to an already-terminal
+        // run (post-run finalize interrupted by restart). Must run before the
+        // idle reconciler so the freed issue is routed in this same pass.
+        this.finalizeDanglingActiveRuns();
         // Preemptively detect stuck merge-queue PRs (conflicts visible on
         // GitHub) and dispatch queue_repair before the Steward evicts.
         await this.queueHealthMonitor.reconcile();
@@ -584,6 +592,67 @@ export class RunOrchestrator {
             isRequestedChangesRunType,
         });
     }
+    // Clear a dangling active slot: an issue still pointing at an
+    // already-terminal run via `activeRunId`. The post-run finalize was
+    // interrupted (almost always a restart between marking the run
+    // terminal and clearing the slot), so the run can never drive the
+    // session forward, yet every idle/recovery pass skips the issue
+    // because `activeRunId` is set. We re-read under the issue-session
+    // lease and null the slot; the idle reconciler then routes the issue
+    // from GitHub truth (e.g. a missed changes_requested → review_fix).
+    finalizeDanglingActiveRuns() {
+        for (const issue of this.db.issues.listIssuesWithTerminalActiveRun()) {
+            if (issue.activeRunId === undefined)
+                continue;
+            const run = this.db.runs.getRunById(issue.activeRunId);
+            // The query already filters to terminal runs; this guards against a
+            // race where the run advanced back to active between query and read.
+            if (!run || run.status === "running" || run.status === "queued")
+                continue;
+            // Hold off until the run has been terminal long enough that the
+            // normal notification-driven finalize has demonstrably not run —
+            // avoids racing a live completion that is milliseconds from clearing
+            // the slot itself.
+            const endedAtMs = run.endedAt ? Date.parse(run.endedAt) : Number.NaN;
+            if (Number.isFinite(endedAtMs) && Date.now() - endedAtMs < DANGLING_ACTIVE_RUN_MIN_AGE_MS)
+                continue;
+            const lease = this.claimLeaseForReconciliation(run.projectId, run.linearIssueId);
+            // "skip" → a live lease owns the session (a real run is in flight);
+            // leave it alone. "owned" → an outer local scope holds it, so we
+            // must not release it here.
+            if (lease === "skip")
+                continue;
+            try {
+                const cleared = this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, (held) => {
+                    const fresh = this.db.issues.getIssue(run.projectId, run.linearIssueId);
+                    if (!fresh || fresh.activeRunId !== run.id)
+                        return false;
+                    this.db.issueSessions.upsertIssueWithLease(held, {
+                        projectId: run.projectId,
+                        linearIssueId: run.linearIssueId,
+                        activeRunId: null,
+                    });
+                    return true;
+                });
+                if (cleared) {
+                    this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, runStatus: run.status }, "Cleared dangling active-run slot left by a terminal run; idle reconcile will resume the issue");
+                    this.feed?.publish({
+                        level: "warn",
+                        kind: "workflow",
+                        issueKey: issue.issueKey,
+                        projectId: run.projectId,
+                        stage: run.runType,
+                        status: "recovered",
+                        summary: `Cleared stuck active slot: run #${run.id} was ${run.status} but still held the issue`,
+                    });
+                }
+            }
+            finally {
+                if (lease !== "owned")
+                    this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
+            }
+        }
+    }
     async reconcileRun(run) {
         const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
         if (!issue)

package/dist/service-queue.js

@@ -74,7 +74,7 @@ export class SerialWorkQueue {
                 const nextAttempt = entry.attempt + 1;
                 const retry = this.options.retryOnError?.(err, entry.item, nextAttempt);
                 if (retry) {
-                    this.logger.warn({ item: entry.item, error: err.message, attempt: nextAttempt, retryDelayMs: retry.delayMs }, "Queue item processing failed; retrying");
+                    this.logger[retry.logLevel ?? "warn"]({ item: entry.item, error: err.message, attempt: nextAttempt, retryDelayMs: retry.delayMs }, retry.message ?? "Queue item processing failed; retrying");
                     this.scheduleRetry({ item: entry.item, attempt: nextAttempt }, retry.delayMs);
                     continue;
                 }

package/dist/service-runtime.js

@@ -4,6 +4,8 @@ const ISSUE_KEY_DELIMITER = "::";
 const DEFAULT_RECONCILE_INTERVAL_MS = 5_000;
 const DEFAULT_RECONCILE_TIMEOUT_MS = 60_000;
 const DEFAULT_MAX_ACTIVE_ISSUE_RUNS = 4;
+const DEFAULT_ISSUE_RUN_CAPACITY_RETRY_DELAY_MS = 5_000;
+const EVENT_LOOP_MONITOR_INTERVAL_MS = 1_000;
 function makeIssueQueueKey(item) {
     return `${item.projectId}${ISSUE_KEY_DELIMITER}${item.issueId}`;
 }
@@ -21,6 +23,9 @@ export class ServiceRuntime {
     githubAppAuthError;
     startupError;
     reconcileTimer;
+    eventLoopMonitorTimer;
+    eventLoopMonitorExpectedAt = 0;
+    eventLoopLagMs = 0;
     reconcileInProgress = false;
     constructor(codex, logger, runReconciler, readyIssueSource, webhookProcessor, issueProcessor, options = {}) {
         this.codex = codex;
@@ -29,13 +34,23 @@ export class ServiceRuntime {
         this.readyIssueSource = readyIssueSource;
         this.options = options;
         this.webhookQueue = new SerialWorkQueue((eventId) => webhookProcessor.processWebhookEvent(eventId), logger, (eventId) => String(eventId));
-        this.issueQueue = new SerialWorkQueue((item) => issueProcessor.processIssue(item), logger, makeIssueQueueKey, {
-            retryOnError: (error, _item, attempt) => retrySqliteLockedQueueFailure(error, attempt),
+        this.issueQueue = new SerialWorkQueue((item) => this.processIssueWithCapacity(item, issueProcessor), logger, makeIssueQueueKey, {
+            retryOnError: (error, _item, attempt) => {
+                if (error instanceof IssueRunCapacityFullError) {
+                    return {
+                        delayMs: this.getIssueRunCapacityRetryDelayMs(),
+                        logLevel: "debug",
+                        message: "Issue run capacity is full; keeping item queued for retry",
+                    };
+                }
+                return retrySqliteLockedQueueFailure(error, attempt);
+            },
         });
     }
     async start() {
         try {
             await this.codex.start();
+            this.startEventLoopMonitor();
             for (const issue of this.readyIssueSource.listIssuesReadyForExecution()) {
                 this.enqueueIssue(issue.projectId, issue.linearIssueId);
             }
@@ -52,22 +67,13 @@ export class ServiceRuntime {
     async stop() {
         this.ready = false;
         this.clearBackgroundReconcile();
+        this.clearEventLoopMonitor();
         await this.codex.stop();
     }
     enqueueWebhookEvent(eventId, options) {
         this.webhookQueue.enqueue(eventId, options);
     }
     enqueueIssue(projectId, issueId) {
-        if (!this.hasIssueRunCapacity()) {
-            this.logger.warn({
-                projectId,
-                issueId,
-                activeIssueRuns: this.getActiveIssueRunCount(),
-                queuedIssueRuns: this.issueQueue.size(),
-                maxActiveIssueRuns: this.getMaxActiveIssueRuns(),
-            }, "Skipped issue enqueue: active run capacity is full");
-            return;
-        }
         this.issueQueue.enqueue({ projectId, issueId });
     }
     setLinearConnected(connected) {
@@ -83,10 +89,29 @@ export class ServiceRuntime {
             codexStarted: this.codex.isStarted(),
             linearConnected: this.linearConnected,
             githubAppAuthHealthy: this.githubAppAuthHealthy,
+            eventLoopLagMs: this.eventLoopLagMs,
             ...(this.githubAppAuthError ? { githubAppAuthError: this.githubAppAuthError } : {}),
             ...(this.startupError ? { startupError: this.startupError } : {}),
         };
     }
+    startEventLoopMonitor() {
+        this.clearEventLoopMonitor();
+        this.eventLoopMonitorExpectedAt = Date.now() + EVENT_LOOP_MONITOR_INTERVAL_MS;
+        const timer = setInterval(() => {
+            const now = Date.now();
+            this.eventLoopLagMs = Math.max(0, now - this.eventLoopMonitorExpectedAt);
+            this.eventLoopMonitorExpectedAt = now + EVENT_LOOP_MONITOR_INTERVAL_MS;
+        }, EVENT_LOOP_MONITOR_INTERVAL_MS);
+        timer.unref?.();
+        this.eventLoopMonitorTimer = timer;
+    }
+    clearEventLoopMonitor() {
+        if (this.eventLoopMonitorTimer !== undefined) {
+            clearInterval(this.eventLoopMonitorTimer);
+            this.eventLoopMonitorTimer = undefined;
+        }
+        this.eventLoopLagMs = 0;
+    }
     scheduleBackgroundReconcile() {
         this.clearBackgroundReconcile();
         const timer = setTimeout(() => {
@@ -114,9 +139,6 @@ export class ServiceRuntime {
             // 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()) {
-                if (!this.hasIssueRunCapacity()) {
-                    break;
-                }
                 this.enqueueIssue(issue.projectId, issue.linearIssueId);
             }
         }
@@ -134,11 +156,30 @@ export class ServiceRuntime {
         const configured = this.options.maxActiveIssueRuns ?? DEFAULT_MAX_ACTIVE_ISSUE_RUNS;
         return Math.max(1, Math.floor(configured));
     }
+    getIssueRunCapacityRetryDelayMs() {
+        const configured = this.options.issueRunCapacityRetryDelayMs ?? DEFAULT_ISSUE_RUN_CAPACITY_RETRY_DELAY_MS;
+        return Math.max(1, Math.floor(configured));
+    }
     getActiveIssueRunCount() {
         return Math.max(0, this.readyIssueSource.countActiveIssueRuns?.() ?? 0);
     }
-    hasIssueRunCapacity() {
-        return this.getActiveIssueRunCount() + this.issueQueue.size() < this.getMaxActiveIssueRuns();
+    async processIssueWithCapacity(item, processor) {
+        const activeIssueRuns = this.getActiveIssueRunCount();
+        const maxActiveIssueRuns = this.getMaxActiveIssueRuns();
+        if (activeIssueRuns >= maxActiveIssueRuns) {
+            throw new IssueRunCapacityFullError(activeIssueRuns, maxActiveIssueRuns);
+        }
+        await processor.processIssue(item);
+    }
+}
+class IssueRunCapacityFullError extends Error {
+    activeIssueRuns;
+    maxActiveIssueRuns;
+    constructor(activeIssueRuns, maxActiveIssueRuns) {
+        super(`active issue run capacity is full (${activeIssueRuns}/${maxActiveIssueRuns})`);
+        this.activeIssueRuns = activeIssueRuns;
+        this.maxActiveIssueRuns = maxActiveIssueRuns;
+        this.name = "IssueRunCapacityFullError";
     }
 }
 function promiseWithTimeout(promise, timeoutMs, label) {

package/dist/service.js

@@ -14,6 +14,7 @@ import { ServiceStartupRecovery } from "./service-startup-recovery.js";
 import { WakeDispatcher } from "./wake-dispatcher.js";
 import { WebhookHandler } from "./webhook-handler.js";
 import { acceptIncomingWebhook } from "./service-webhooks.js";
+import { runWebhookEventRetention } from "./event-retention.js";
 import { parseStringArray, TrackedIssueListQuery } from "./tracked-issue-list-query.js";
 import { AgentInputService } from "./agent-input-service.js";
 import { CodexFollowupIntentClassifier } from "./followup-intent.js";
@@ -36,6 +37,7 @@ export class PatchRelayService {
     issueActions;
     startupRecovery;
     trackedIssueListQuery;
+    eventRetentionTimer;
     constructor(config, db, codex, linearProvider, logger, configPath) {
         this.config = config;
         this.db = db;
@@ -181,6 +183,7 @@ export class PatchRelayService {
             });
         }
         await this.runtime.start();
+        this.scheduleEventRetention(60_000);
         void this.startupRecovery.recoverDelegatedIssueStateFromLinear().catch((error) => {
             const msg = error instanceof Error ? error.message : String(error);
             this.logger.warn({ error: msg }, "Background delegated issue recovery failed");
@@ -191,6 +194,10 @@ export class PatchRelayService {
         });
     }
     async stop() {
+        if (this.eventRetentionTimer !== undefined) {
+            clearTimeout(this.eventRetentionTimer);
+            this.eventRetentionTimer = undefined;
+        }
         this.githubAppTokenManager?.stop();
         await this.runtime.stop();
     }
@@ -280,6 +287,37 @@ export class PatchRelayService {
     getReadiness() {
         return this.runtime.getReadiness();
     }
+    scheduleEventRetention(delayMs = 24 * 60 * 60 * 1000) {
+        if (this.eventRetentionTimer !== undefined) {
+            clearTimeout(this.eventRetentionTimer);
+        }
+        const timer = setTimeout(() => {
+            void this.runEventRetentionMaintenance();
+        }, delayMs);
+        timer.unref?.();
+        this.eventRetentionTimer = timer;
+    }
+    async runEventRetentionMaintenance() {
+        try {
+            const result = await runWebhookEventRetention({
+                db: this.db,
+                config: this.config,
+            });
+            if (result.deleted > 0 || result.archived > 0 || result.remaining > 0) {
+                this.logger.info(result, "Webhook event retention maintenance completed");
+            }
+            if (this.config.database.wal) {
+                const checkpoint = this.db.runWalCheckpoint("PASSIVE");
+                this.logger.debug({ checkpoint }, "SQLite WAL checkpoint completed");
+            }
+        }
+        catch (error) {
+            this.logger.warn({ error: error instanceof Error ? error.message : String(error) }, "Webhook event retention maintenance failed");
+        }
+        finally {
+            this.scheduleEventRetention();
+        }
+    }
     listTrackedIssues() {
         return this.trackedIssueListQuery.listTrackedIssues();
     }

package/package.json

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