patchrelay 0.73.4 → 0.74.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.73.4",
-  "commit": "94b5acdba50b",
-  "builtAt": "2026-05-27T20:52:10.985Z"
+  "version": "0.74.1",
+  "commit": "7763c9d8b14a",
+  "builtAt": "2026-05-28T19:52:29.055Z"
 }

package/dist/cli/commands/setup.js

@@ -175,6 +175,41 @@ async function readPatchRelayHealth() {
         };
     }
 }
+function getPatchRelayServiceUrl() {
+    const config = loadConfig(undefined, { profile: "doctor" });
+    const host = config.server.bind === "0.0.0.0" ? "127.0.0.1" : config.server.bind;
+    const baseUrl = `http://${host}:${config.server.port}`;
+    return {
+        baseUrl,
+        healthPath: `${baseUrl}${config.server.healthPath}`,
+        codexStatusPath: `${baseUrl}/status`,
+    };
+}
+async function readPatchRelayCodexStatus() {
+    const { codexStatusPath } = getPatchRelayServiceUrl();
+    try {
+        const response = await fetch(codexStatusPath, { signal: AbortSignal.timeout(2_000) });
+        const payload = await response.json();
+        return {
+            reachable: true,
+            status: response.status,
+            payload: {
+                ...payload,
+                output: typeof payload.output === "string" ? payload.output : "",
+                ...(typeof payload.account === "string" ? { account: payload.account } : {}),
+                exitCode: typeof payload.exitCode === "number" ? payload.exitCode : 1,
+                ok: payload.ok === true,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            reachable: false,
+            status: 0,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
 export async function handleServiceCommand(params) {
     if (params.commandArgs.length === 0) {
         throw new CliUsageError("patchrelay service requires a subcommand.", "service");
@@ -229,6 +264,24 @@ export async function handleServiceCommand(params) {
                 .join("\n") + "\n");
         return 0;
     }
+    if (subcommand === "codex-status") {
+        const result = await readPatchRelayCodexStatus();
+        if (!result.reachable) {
+            throw new Error(`Unable to read PatchRelay Codex status. ${result.error}`);
+        }
+        const status = result.payload;
+        const output = status.output.trim();
+        if (params.json) {
+            writeOutput(params.stdout, formatJson(status));
+            return status.ok ? 0 : 1;
+        }
+        const lines = [
+            "PatchRelay Codex status",
+            output ? output : "No codex status output received.",
+        ].filter(Boolean);
+        writeOutput(params.stdout, `${lines.join("\n")}\n`);
+        return status.ok ? 0 : 1;
+    }
     if (subcommand === "logs") {
         const lines = parsePositiveIntegerFlag(params.parsed.flags.get("lines"), "--lines") ?? 50;
         const result = await params.runCommand("sudo", [

package/dist/cli/data.js

@@ -98,6 +98,9 @@ export class CliDataAccess extends CliOperatorApiClient {
         super(config);
         this.config = config;
         this.db = options?.db ?? new PatchRelayDatabase(config.database.path, config.database.wal);
+        if (!options?.db) {
+            this.db.assertSchemaReady();
+        }
         this.codex = options?.codex;
     }
     close() {

package/dist/cli/help.js

@@ -43,6 +43,7 @@ export function rootHelpText() {
         "  issue close <issueKey> [--failed] [--reason <text>] [--json]",
         "                                                          Force-close one issue and release any active run",
         "  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",
         "  service logs [--lines <count>] [--json]                 Show recent service logs",
         "  serve                                                   Run the local PatchRelay service",
@@ -178,6 +179,7 @@ export function serviceHelpText() {
         "  install [--force] [--write-only] [--json]  Reinstall the systemd service unit",
         "  restart [--json]                           Reload-or-restart the service",
         "  status [--json]                            Show systemd state and local health",
+        "  codex-status [--json]                      Show Codex account and usage snapshot from this service",
         "  logs [--lines <count>] [--json]            Show recent journal logs",
         "",
         "Examples:",

package/dist/cli/index.js

@@ -141,6 +141,10 @@ function validateFlags(command, commandArgs, parsed) {
                 assertKnownFlags(parsed, "service", ["json"]);
                 return;
             }
+            if (commandArgs[0] === "codex-status") {
+                assertKnownFlags(parsed, "service", ["json"]);
+                return;
+            }
             if (commandArgs[0] === "logs") {
                 assertKnownFlags(parsed, "service", ["lines", "json"]);
                 return;

package/dist/codex-status.js

@@ -0,0 +1,41 @@
+import { spawnSync } from "node:child_process";
+const CODEX_STATUS_TIMEOUT_MS = 15_000;
+function stripAnsiCodes(value) {
+    return value.replace(/\u001b\[[0-9;]*m/g, "");
+}
+function parseAccountLine(output) {
+    const lines = output.split(/\r?\n/);
+    for (const line of lines) {
+        const clean = stripAnsiCodes(line).trim();
+        const match = clean.match(/^Account:\s*(.+)$/i);
+        if (match) {
+            return match[1].trim();
+        }
+    }
+    return undefined;
+}
+export function getCodexStatusSnapshot(bin = "codex") {
+    try {
+        const result = spawnSync(bin, ["status"], {
+            encoding: "utf8",
+            timeout: CODEX_STATUS_TIMEOUT_MS,
+            env: { ...process.env },
+        });
+        const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trimEnd();
+        const account = parseAccountLine(output);
+        return {
+            ok: result.status === 0,
+            exitCode: result.status ?? 1,
+            output,
+            ...(account ? { account } : {}),
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            exitCode: 1,
+            output: "",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

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

@@ -1,4 +1,5 @@
 import { deriveSessionWakePlan, isActionableIssueSessionEventType } from "../issue-session-events.js";
+import { mergeRequestedChangesEventJson, readRequestedChangesCoalesceKey } from "../reactive-wake-keys.js";
 import { isoNow } from "./shared.js";
 export class IssueSessionStore {
     connection;
@@ -33,6 +34,9 @@ export class IssueSessionStore {
             if (existing)
                 return this.mapIssueSessionEventRow(existing);
         }
+        const coalesced = this.coalescePendingRequestedChangesEvent(params);
+        if (coalesced)
+            return coalesced;
         const now = isoNow();
         const result = this.connection.prepare(`
       INSERT INTO issue_session_events (
@@ -41,6 +45,27 @@ export class IssueSessionStore {
     `).run(params.projectId, params.linearIssueId, params.eventType, params.eventJson ?? null, params.dedupeKey ?? null, now);
         return this.getIssueSessionEvent(Number(result.lastInsertRowid));
     }
+    coalescePendingRequestedChangesEvent(params) {
+        if (params.eventType !== "review_changes_requested")
+            return undefined;
+        const coalesceKey = readRequestedChangesCoalesceKey(params.eventJson);
+        if (!coalesceKey)
+            return undefined;
+        const existing = this.listIssueSessionEvents(params.projectId, params.linearIssueId, { pendingOnly: true })
+            .filter((event) => event.eventType === "review_changes_requested")
+            .find((event) => readRequestedChangesCoalesceKey(event.eventJson) === coalesceKey);
+        if (!existing)
+            return undefined;
+        const mergedJson = mergeRequestedChangesEventJson(existing.eventJson, params.eventJson);
+        if (mergedJson !== existing.eventJson) {
+            this.connection.prepare(`
+        UPDATE issue_session_events
+        SET event_json = ?
+        WHERE id = ? AND processed_at IS NULL
+      `).run(mergedJson ?? null, existing.id);
+        }
+        return this.getIssueSessionEvent(existing.id) ?? existing;
+    }
     appendIssueSessionEventWithLease(lease, params) {
         return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => this.appendIssueSessionEvent(params));
     }
@@ -80,6 +105,16 @@ export class IssueSessionStore {
       WHERE project_id = ? AND linear_issue_id = ? AND id IN (${placeholders}) AND processed_at IS NULL
     `).run(now, runId, projectId, linearIssueId, ...eventIds);
     }
+    dismissIssueSessionEvents(projectId, linearIssueId, eventIds) {
+        if (eventIds.length === 0)
+            return;
+        const placeholders = eventIds.map(() => "?").join(", ");
+        this.connection.prepare(`
+      UPDATE issue_session_events
+      SET processed_at = ?, consumed_by_run_id = NULL
+      WHERE project_id = ? AND linear_issue_id = ? AND id IN (${placeholders}) AND processed_at IS NULL
+    `).run(isoNow(), projectId, linearIssueId, ...eventIds);
+    }
     clearPendingIssueSessionEvents(projectId, linearIssueId) {
         this.connection.prepare(`
       UPDATE issue_session_events
@@ -99,7 +134,7 @@ export class IssueSessionStore {
         const plan = deriveSessionWakePlan(issue, events);
         if (plan?.runType) {
             return {
-                eventIds: events.map((event) => event.id),
+                eventIds: plan.eventIds,
                 runType: plan.runType,
                 context: plan.context,
                 ...(plan.wakeReason ? { wakeReason: plan.wakeReason } : {}),
@@ -220,6 +255,12 @@ export class IssueSessionStore {
             return true;
         }) ?? false;
     }
+    dismissIssueSessionEventsWithLease(lease, eventIds) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.dismissIssueSessionEvents(lease.projectId, lease.linearIssueId, eventIds);
+            return true;
+        }) ?? false;
+    }
     clearPendingIssueSessionEventsWithLease(lease) {
         return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
             this.clearPendingIssueSessionEvents(lease.projectId, lease.linearIssueId);

package/dist/db/schema-guard.js

@@ -0,0 +1,17 @@
+const REQUIRED_PATCHRELAY_TABLES = [
+    "issues",
+    "runs",
+    "issue_sessions",
+    "issue_session_events",
+];
+export function assertPatchRelaySchemaReady(connection, databasePath) {
+    const rows = connection
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table'")
+        .all();
+    const tables = new Set(rows.map((row) => String(row.name)));
+    const missing = REQUIRED_PATCHRELAY_TABLES.filter((table) => !tables.has(table));
+    if (missing.length === 0) {
+        return;
+    }
+    throw new Error(`PatchRelay database is uninitialized or points at the wrong path: ${databasePath}. Missing required table(s): ${missing.join(", ")}`);
+}

package/dist/db.js

@@ -7,6 +7,7 @@ import { RepositoryLinkStore } from "./db/repository-link-store.js";
 import { RunStore } from "./db/run-store.js";
 import { WebhookEventStore } from "./db/webhook-event-store.js";
 import { runPatchRelayMigrations } from "./db/migrations.js";
+import { assertPatchRelaySchemaReady } from "./db/schema-guard.js";
 import { SqliteConnection } from "./db/shared.js";
 import { syncIssueSessionFromIssue } from "./issue-session-projector.js";
 import { TrackedIssueQuery } from "./tracked-issue-query.js";
@@ -23,6 +24,7 @@ export class PatchRelayDatabase {
     runs;
     trackedIssues;
     constructor(databasePath, wal) {
+        this.databasePath = databasePath;
         this.connection = new SqliteConnection(databasePath);
         this.connection.pragma("foreign_keys = ON");
         if (wal) {
@@ -45,8 +47,13 @@ export class PatchRelayDatabase {
         this.workflowWakes = new WorkflowWakeResolver(this.issues, this.issueSessions);
         this.trackedIssues = new TrackedIssueQuery(this.issues, this.issueSessions, this.workflowWakes, this.runs);
     }
+    databasePath;
     runMigrations() {
         runPatchRelayMigrations(this.connection);
+        this.assertSchemaReady();
+    }
+    assertSchemaReady() {
+        assertPatchRelaySchemaReady(this.connection, this.databasePath);
     }
     transaction(fn) {
         return this.connection.transaction(fn)();

package/dist/github-cli-auth.js

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
 import path from "node:path";
 /**
  * Unified GitHub App credential delivery for `git` and the `gh` CLI.
@@ -88,3 +89,45 @@ export function buildAgentChildEnv(parentEnv = process.env) {
     delete env.GITHUB_TOKEN;
     return env;
 }
+export async function verifyGitHubCliAuthEnv(env = process.env, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 10_000;
+    await new Promise((resolve, reject) => {
+        const child = spawn("git", ["credential", "fill"], {
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stderr = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            child.kill("SIGTERM");
+            reject(new Error(`GitHub git credential check timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref?.();
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const detail = stderr.trim();
+            reject(new Error(`GitHub git credential check failed${detail ? `: ${detail}` : ""}`));
+        });
+        child.stdin.end(`protocol=https\nhost=${GITHUB_HOST}\n\n`);
+    });
+}

package/dist/github-webhook-reactive-run.js

@@ -3,6 +3,7 @@ import { buildQueueRepairContextFromEvent } from "./merge-queue-incident.js";
 import { isIssueTerminal } from "./pr-state.js";
 import { buildGitHubQueueFailureContext, getRelevantGitHubCiSnapshot, resolveGitHubBranchFailureContext, resolveGitHubCheckClass, } from "./github-webhook-failure-context.js";
 import { isQueueEvictionFailure, isSettledBranchFailure } from "./github-webhook-policy.js";
+import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
 export async function maybeEnqueueGitHubReactiveRun(params) {
     const { issue, event, project, logger, feed, wakeDispatcher, db, fetchImpl, failureContextResolver } = params;
     if (isIssueTerminal(issue))
@@ -159,9 +160,18 @@ async function handleRequestedChangesEvent(params) {
         }, "Failed to fetch inline review comments for requested-changes event");
         return undefined;
     });
+    const identity = buildRequestedChangesWakeIdentity({
+        linearIssueId: issue.linearIssueId,
+        headSha: issue.prHeadSha ?? event.headSha,
+        reviewCommitId: event.reviewCommitId,
+        reviewId: event.reviewId,
+        reviewerName: event.reviewerName,
+    });
     const queuedRunType = wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
         eventType: "review_changes_requested",
         eventJson: JSON.stringify({
+            requestedChangesCoalesceKey: identity.coalesceKey,
+            ...(identity.headSha ? { requestedChangesHeadSha: identity.headSha } : {}),
             reviewBody: event.reviewBody,
             reviewCommitId: event.reviewCommitId,
             reviewId: event.reviewId,
@@ -169,11 +179,7 @@ async function handleRequestedChangesEvent(params) {
             reviewerName: event.reviewerName,
             ...(reviewComments && reviewComments.length > 0 ? { reviewComments } : {}),
         }),
-        dedupeKey: [
-            "review_changes_requested",
-            issue.prHeadSha ?? event.headSha ?? "unknown-sha",
-            event.reviewerName ?? "unknown-reviewer",
-        ].join("::"),
+        dedupeKey: identity.dedupeKey,
     });
     logger.info({
         issueKey: issue.issueKey,

package/dist/http.js

@@ -1,6 +1,7 @@
 import fastify from "fastify";
 import rawBody from "fastify-raw-body";
 import { getBuildInfo } from "./build-info.js";
+import { getCodexStatusSnapshot } from "./codex-status.js";
 export async function buildHttpServer(config, service, logger) {
     const buildInfo = getBuildInfo();
     const loopbackBind = isLoopbackBind(config.server.bind);
@@ -244,6 +245,14 @@ export async function buildHttpServer(config, service, logger) {
         });
     }
     if (managementRoutesEnabled) {
+        app.get("/status", async (_request, reply) => {
+            const status = getCodexStatusSnapshot(config.runner.codex.bin);
+            return reply.code(status.ok ? 200 : 502).send(status);
+        });
+        app.get("/api/codex/status", async (_request, reply) => {
+            const status = getCodexStatusSnapshot(config.runner.codex.bin);
+            return reply.code(status.ok ? 200 : 502).send(status);
+        });
         app.get("/api/issues", async (_request, reply) => {
             return reply.send({ ok: true, issues: service.listTrackedIssues() });
         });

package/dist/idle-reconciliation.js

@@ -9,6 +9,7 @@ import { getReviewFixBudget } from "./run-budgets.js";
 import { queueSettledOrchestrationIssue } from "./orchestration-parent-wake.js";
 import { fetchPullRequestSnapshot } from "./reconcile-pr-fetch.js";
 import { buildPrStateUpdates } from "./reconcile-pr-state-updates.js";
+import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
 import { execCommand } from "./utils.js";
 export class IdleIssueReconciler {
     db;
@@ -288,15 +289,34 @@ export class IdleIssueReconciler {
         }
         else if (runType === "review_fix" || runType === "branch_upkeep") {
             eventType = "review_changes_requested";
-            dedupeKey = `${dedupeScope}:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown"}`;
+            dedupeKey = buildRequestedChangesWakeIdentity({
+                linearIssueId: issue.linearIssueId,
+                runType,
+                headSha: issue.prHeadSha,
+            }).dedupeKey;
         }
         else {
             eventType = "delegated";
             dedupeKey = `${dedupeScope}:implementation:${issue.linearIssueId}`;
         }
+        const requestedChangesIdentity = eventType === "review_changes_requested"
+            ? buildRequestedChangesWakeIdentity({
+                linearIssueId: issue.linearIssueId,
+                runType: runType === "branch_upkeep" ? "branch_upkeep" : "review_fix",
+                headSha: issue.prHeadSha,
+            })
+            : undefined;
         this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
             eventType,
-            ...(context ? { eventJson: JSON.stringify(context) } : {}),
+            ...(context || requestedChangesIdentity ? {
+                eventJson: JSON.stringify({
+                    ...context,
+                    ...(requestedChangesIdentity ? {
+                        requestedChangesCoalesceKey: requestedChangesIdentity.coalesceKey,
+                        ...(requestedChangesIdentity.headSha ? { requestedChangesHeadSha: requestedChangesIdentity.headSha } : {}),
+                    } : {}),
+                }),
+            } : {}),
             dedupeKey,
         });
     }

package/dist/issue-session-events.js

@@ -10,6 +10,7 @@ const TERMINAL_SESSION_EVENTS = new Set([
 const NON_ACTIONABLE_SESSION_EVENTS = new Set([
     "delegation_observed",
     "prompt_delivered",
+    "self_comment",
     "run_released_authority",
 ]);
 // "main_repair" was removed as a run type; legacy session-event payloads carrying it
@@ -28,6 +29,7 @@ export function deriveSessionWakePlan(issue, events) {
     }
     const context = {};
     const followUps = [];
+    let eventIds = [];
     let wakeReason;
     let runType;
     let resumeThread = false;
@@ -37,12 +39,14 @@ export function deriveSessionWakePlan(issue, events) {
             case "merge_steward_incident":
                 runType = "queue_repair";
                 wakeReason = "merge_steward_incident";
+                eventIds = [event.id];
                 Object.assign(context, payload ?? {});
                 break;
             case "settled_red_ci":
                 if (runType !== "queue_repair") {
                     runType = "ci_repair";
                     wakeReason = "settled_red_ci";
+                    eventIds = [event.id];
                     Object.assign(context, payload ?? {});
                 }
                 break;
@@ -50,6 +54,7 @@ export function deriveSessionWakePlan(issue, events) {
                 if (runType !== "queue_repair" && runType !== "ci_repair") {
                     runType = payload?.branchUpkeepRequired === true ? "branch_upkeep" : "review_fix";
                     wakeReason = payload?.branchUpkeepRequired === true ? "branch_upkeep" : "review_changes_requested";
+                    eventIds = [event.id];
                     Object.assign(context, payload ?? {});
                 }
                 break;
@@ -57,6 +62,10 @@ export function deriveSessionWakePlan(issue, events) {
                 if (!runType) {
                     runType = parseRunType(payload?.runType) ?? "implementation";
                     wakeReason = issue.issueClass === "orchestration" ? "initial_delegate" : "delegated";
+                    eventIds = [event.id];
+                }
+                else {
+                    eventIds.push(event.id);
                 }
                 Object.assign(context, payload ?? {});
                 break;
@@ -66,6 +75,10 @@ export function deriveSessionWakePlan(issue, events) {
                 if (!runType) {
                     runType = "implementation";
                     wakeReason = event.eventType;
+                    eventIds = [event.id];
+                }
+                else {
+                    eventIds.push(event.id);
                 }
                 Object.assign(context, payload ?? {});
                 resumeThread = true;
@@ -74,6 +87,10 @@ export function deriveSessionWakePlan(issue, events) {
                 if (!runType) {
                     runType = issue.prReviewState === "changes_requested" ? "review_fix" : "implementation";
                     wakeReason = "direct_reply";
+                    eventIds = [event.id];
+                }
+                else {
+                    eventIds.push(event.id);
                 }
                 const text = typeof payload?.text === "string"
                     ? payload.text
@@ -94,6 +111,10 @@ export function deriveSessionWakePlan(issue, events) {
                     runType = parseRunType(payload?.runType)
                         ?? (issue.prReviewState === "changes_requested" ? "review_fix" : "implementation");
                     wakeReason = "completion_check_continue";
+                    eventIds = [event.id];
+                }
+                else {
+                    eventIds.push(event.id);
                 }
                 if (typeof payload?.summary === "string" && payload.summary.trim()) {
                     context.completionCheckSummary = payload.summary.trim();
@@ -108,6 +129,10 @@ export function deriveSessionWakePlan(issue, events) {
                 if (!runType) {
                     runType = issue.prReviewState === "changes_requested" ? "review_fix" : "implementation";
                     wakeReason = issue.issueClass === "orchestration" ? "human_instruction" : event.eventType;
+                    eventIds = [event.id];
+                }
+                else {
+                    eventIds.push(event.id);
                 }
                 const text = typeof payload?.text === "string"
                     ? payload.text
@@ -151,7 +176,7 @@ export function deriveSessionWakePlan(issue, events) {
     if (wakeReason) {
         context.wakeReason = wakeReason;
     }
-    return { runType, wakeReason, resumeThread, context };
+    return { eventIds, runType, wakeReason, resumeThread, context };
 }
 export function isActionableIssueSessionEventType(eventType) {
     return !NON_ACTIONABLE_SESSION_EVENTS.has(eventType);

package/dist/operator-retry-event.js

@@ -1,3 +1,4 @@
+import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
 function parseObjectJson(value) {
     if (!value)
         return undefined;
@@ -42,16 +43,23 @@ export function buildOperatorRetryEvent(issue, runType, source = "operator_retry
         };
     }
     if (runType === "review_fix" || runType === "branch_upkeep") {
+        const identity = buildRequestedChangesWakeIdentity({
+            linearIssueId: issue.linearIssueId,
+            runType,
+            headSha: issue.prHeadSha,
+        });
         return {
             eventType: "review_changes_requested",
             eventJson: JSON.stringify({
+                requestedChangesCoalesceKey: identity.coalesceKey,
+                ...(identity.headSha ? { requestedChangesHeadSha: identity.headSha } : {}),
                 ...(runType === "branch_upkeep"
                     ? { reviewBody: `${humanizeSource(source)} requested retry of branch upkeep after requested changes.` }
                     : { promptContext: `${humanizeSource(source)} requested retry of review-fix work.` }),
                 ...(runType === "branch_upkeep" ? { branchUpkeepRequired: true, wakeReason: "branch_upkeep" } : {}),
                 source,
             }),
-            dedupeKey: `${source}:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`,
+            dedupeKey: identity.dedupeKey,
         };
     }
     return {

package/dist/preflight.js

@@ -1,6 +1,7 @@
 import { accessSync, constants, existsSync, mkdirSync, statSync } from "node:fs";
 import path from "node:path";
 import { runPatchRelayMigrations } from "./db/migrations.js";
+import { assertPatchRelaySchemaReady } from "./db/schema-guard.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { SqliteConnection } from "./db/shared.js";
 import { execCommand } from "./utils.js";
@@ -132,6 +133,7 @@ function checkDatabaseHealth(config) {
             connection.pragma("journal_mode = WAL");
         }
         runPatchRelayMigrations(connection);
+        assertPatchRelaySchemaReady(connection, config.database.path);
         const quickCheck = connection.prepare("PRAGMA quick_check").get();
         const quickCheckResult = quickCheck ? Object.values(quickCheck)[0] : undefined;
         if (quickCheckResult !== "ok") {

package/dist/reactive-wake-keys.js

@@ -0,0 +1,64 @@
+const UNKNOWN_HEAD = "unknown-sha";
+export function buildRequestedChangesWakeIdentity(params) {
+    const runType = params.runType ?? "review_fix";
+    const headSha = params.reviewCommitId ?? params.headSha;
+    const coalesceHead = headSha ?? UNKNOWN_HEAD;
+    const coalesceKey = `review_changes_requested:${runType}:issue:${params.linearIssueId}:head:${coalesceHead}`;
+    if (params.reviewId !== undefined && params.reviewId !== null) {
+        return {
+            dedupeKey: `review_changes_requested:${runType}:issue:${params.linearIssueId}:review:${params.reviewId}`,
+            coalesceKey,
+            ...(headSha ? { headSha } : {}),
+        };
+    }
+    if (headSha && params.reviewerName) {
+        return {
+            dedupeKey: `review_changes_requested:${runType}:issue:${params.linearIssueId}:head:${headSha}:reviewer:${params.reviewerName}`,
+            coalesceKey,
+            headSha,
+        };
+    }
+    return {
+        dedupeKey: coalesceKey,
+        coalesceKey,
+        ...(headSha ? { headSha } : {}),
+    };
+}
+export function readRequestedChangesCoalesceKey(eventJson) {
+    if (!eventJson)
+        return undefined;
+    try {
+        const parsed = JSON.parse(eventJson);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return undefined;
+        const value = parsed.requestedChangesCoalesceKey;
+        return typeof value === "string" && value.trim() ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function mergeRequestedChangesEventJson(existingJson, incomingJson) {
+    if (!incomingJson)
+        return existingJson;
+    const incoming = parseObject(incomingJson);
+    if (!incoming)
+        return existingJson;
+    const existing = parseObject(existingJson);
+    if (!existing)
+        return incomingJson;
+    return JSON.stringify({ ...existing, ...incoming });
+}
+function parseObject(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/run-notification-handler.js

@@ -4,6 +4,7 @@ import { resolveRecoverablePostRunState } from "./interrupted-run-recovery.js";
 function isRequestedChangesRunType(runType) {
     return runType === "review_fix" || runType === "branch_upkeep";
 }
+const DEFAULT_PUBLISH_COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
 export class RunNotificationHandler {
     config;
     db;
@@ -15,8 +16,10 @@ export class RunNotificationHandler {
     heartbeatIssueSessionLease;
     releaseIssueSessionLease;
     feed;
+    options;
     activeThreadId;
-    constructor(config, db, logger, linearSync, runFinalizer, readThreadWithRetry, withHeldIssueSessionLease, heartbeatIssueSessionLease, releaseIssueSessionLease, feed) {
+    publishCommandWatchdogs = new Map();
+    constructor(config, db, logger, linearSync, runFinalizer, readThreadWithRetry, withHeldIssueSessionLease, heartbeatIssueSessionLease, releaseIssueSessionLease, feed, options = {}) {
         this.config = config;
         this.db = db;
         this.logger = logger;
@@ -27,6 +30,7 @@ export class RunNotificationHandler {
         this.heartbeatIssueSessionLease = heartbeatIssueSessionLease;
         this.releaseIssueSessionLease = releaseIssueSessionLease;
         this.feed = feed;
+        this.options = options;
     }
     async handle(notification) {
         let threadId = typeof notification.params.threadId === "string" ? notification.params.threadId : undefined;
@@ -50,6 +54,7 @@ export class RunNotificationHandler {
             return;
         }
         const turnId = typeof notification.params.turnId === "string" ? notification.params.turnId : undefined;
+        this.observePublishCommand(notification, run, threadId, turnId ?? run.turnId);
         if (this.config.runner.codex.persistExtendedHistory) {
             this.db.runs.saveThreadEvent({
                 runId: run.id,
@@ -59,15 +64,13 @@ export class RunNotificationHandler {
                 eventJson: JSON.stringify(notification.params),
             });
         }
-        this.linearSync.maybeEmitProgress(notification, run);
+        this.maybeEmitProgress(notification, run);
         if (notification.method === "turn/plan/updated") {
-            const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
-            if (issue) {
-                void this.linearSync.syncCodexPlan(issue, notification.params);
-            }
+            this.syncCodexPlan(notification, run);
         }
         if (notification.method !== "turn/completed")
             return;
+        this.clearPublishWatchdogsForThread(threadId);
         const thread = await this.readThreadWithRetry(threadId);
         const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
         if (!issue)
@@ -137,4 +140,120 @@ export class RunNotificationHandler {
         });
         this.activeThreadId = undefined;
     }
+    observePublishCommand(notification, run, threadId, turnId) {
+        const item = notification.params.item;
+        if (!item || typeof item !== "object") {
+            return;
+        }
+        const itemRecord = item;
+        const itemId = typeof itemRecord.id === "string" ? itemRecord.id : undefined;
+        if (!itemId) {
+            return;
+        }
+        if (notification.method === "item/completed" || isTerminalItemUpdate(notification.method, itemRecord)) {
+            this.clearPublishWatchdog(threadId, itemId);
+            return;
+        }
+        if (notification.method !== "item/started" || itemRecord.type !== "commandExecution" || !turnId || !this.options.interruptTurn) {
+            return;
+        }
+        const command = extractCommandText(itemRecord.command);
+        if (!command || !isGitPushCommand(command)) {
+            return;
+        }
+        const key = publishWatchdogKey(threadId, itemId);
+        if (this.publishCommandWatchdogs.has(key)) {
+            return;
+        }
+        const timeoutMs = this.options.publishCommandTimeoutMs ?? DEFAULT_PUBLISH_COMMAND_TIMEOUT_MS;
+        const timer = setTimeout(() => {
+            this.publishCommandWatchdogs.delete(key);
+            this.logger.warn({ runId: run.id, projectId: run.projectId, issueId: run.linearIssueId, threadId, turnId, timeoutMs }, "Interrupting stuck git push command");
+            this.feed?.publish({
+                level: "error",
+                kind: "turn",
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "interrupted",
+                summary: `Interrupted stuck publish command after ${Math.round(timeoutMs / 1000)}s`,
+            });
+            void this.options.interruptTurn?.({ threadId, turnId }).catch((error) => {
+                this.logger.warn({ runId: run.id, projectId: run.projectId, issueId: run.linearIssueId, threadId, turnId, error: formatError(error) }, "Failed to interrupt stuck git push command");
+            });
+        }, timeoutMs);
+        timer.unref?.();
+        this.publishCommandWatchdogs.set(key, timer);
+    }
+    clearPublishWatchdog(threadId, itemId) {
+        const key = publishWatchdogKey(threadId, itemId);
+        const timer = this.publishCommandWatchdogs.get(key);
+        if (!timer) {
+            return;
+        }
+        clearTimeout(timer);
+        this.publishCommandWatchdogs.delete(key);
+    }
+    clearPublishWatchdogsForThread(threadId) {
+        for (const [key, timer] of this.publishCommandWatchdogs) {
+            if (!key.startsWith(`${threadId}:`)) {
+                continue;
+            }
+            clearTimeout(timer);
+            this.publishCommandWatchdogs.delete(key);
+        }
+    }
+    maybeEmitProgress(notification, run) {
+        try {
+            this.linearSync.maybeEmitProgress(notification, run);
+        }
+        catch (error) {
+            this.logger.warn({ runId: run.id, projectId: run.projectId, issueId: run.linearIssueId, method: notification.method, error: formatError(error) }, "Linear progress reporting failed");
+        }
+    }
+    syncCodexPlan(notification, run) {
+        let issue;
+        try {
+            issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
+        }
+        catch (error) {
+            this.logger.warn({ runId: run.id, projectId: run.projectId, issueId: run.linearIssueId, method: notification.method, error: formatError(error) }, "Linear plan sync lookup failed");
+            return;
+        }
+        if (!issue)
+            return;
+        try {
+            void this.linearSync.syncCodexPlan(issue, notification.params).catch((error) => {
+                this.logger.warn({ runId: run.id, issueKey: issue.issueKey, projectId: run.projectId, issueId: run.linearIssueId, method: notification.method, error: formatError(error) }, "Linear plan sync failed");
+            });
+        }
+        catch (error) {
+            this.logger.warn({ runId: run.id, issueKey: issue.issueKey, projectId: run.projectId, issueId: run.linearIssueId, method: notification.method, error: formatError(error) }, "Linear plan sync failed");
+        }
+    }
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function publishWatchdogKey(threadId, itemId) {
+    return `${threadId}:${itemId}`;
+}
+function extractCommandText(command) {
+    if (typeof command === "string") {
+        return command;
+    }
+    if (Array.isArray(command)) {
+        return command.map((entry) => String(entry)).join(" ");
+    }
+    return undefined;
+}
+function isGitPushCommand(command) {
+    const normalized = command.replace(/\s+/g, " ").trim();
+    return /(?:^|[;&|({\s])git(?:\s+-C\s+\S+)?\s+push(?:\s|$)/.test(normalized);
+}
+function isTerminalItemUpdate(method, item) {
+    if (method !== "item/updated") {
+        return false;
+    }
+    const status = typeof item.status === "string" ? item.status.toLowerCase() : "";
+    return status === "completed" || status === "failed" || status === "cancelled" || status === "canceled";
 }

package/dist/run-orchestrator.js

@@ -129,7 +129,7 @@ export class RunOrchestrator {
         this.issueTriage = new IssueTriageService(codex, logger);
         this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.wakeDispatcher, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.recoveryPorts.failRunAndClear, this.runCompletionPolicy, this.completionCheck, this.publicationRecap, feed);
         this.runLauncher = new RunLauncher(config, db, codex, logger, this.worktreeManager);
-        this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, this.threadPorts.readThreadWithRetry, this.leasePorts.withHeldLease, this.leasePorts.heartbeatLease, this.leasePorts.releaseLease, feed);
+        this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, this.threadPorts.readThreadWithRetry, this.leasePorts.withHeldLease, this.leasePorts.heartbeatLease, this.leasePorts.releaseLease, feed, { interruptTurn: (options) => codex.interruptTurn(options) });
         this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.getHeldLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.leasePorts.releaseLease, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
         this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.recoveryPorts.failRunAndClear, this.recoveryPorts.restoreIdleWorktree, this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
         this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, this.recoveryPorts.recoverOrEscalate, (projectId) => this.config.projects.find((project) => project.id === projectId)?.github?.repoFullName, feed);
@@ -308,6 +308,42 @@ export class RunOrchestrator {
         const baseContext = isRequestedChangesRunType(runType)
             ? await this.runCompletionPolicy.resolveRequestedChangesWakeContext(issue, runType, context)
             : context;
+        const launchIssue = this.db.issues.getIssue(item.projectId, item.issueId) ?? issue;
+        const inactiveRequestedChangesWakeReason = this.resolveInactiveRequestedChangesWakeReason(launchIssue, runType, baseContext);
+        if (inactiveRequestedChangesWakeReason) {
+            const lease = { projectId: item.projectId, linearIssueId: item.issueId, leaseId };
+            const requestedChangesEventIds = this.db.issueSessions
+                .listIssueSessionEvents(item.projectId, item.issueId, { pendingOnly: true })
+                .filter((event) => wake.eventIds.includes(event.id) && event.eventType === "review_changes_requested")
+                .map((event) => event.id);
+            const dismissed = this.db.issueSessions.dismissIssueSessionEventsWithLease(lease, requestedChangesEventIds);
+            if (!dismissed) {
+                this.releaseIssueSessionLease(item.projectId, item.issueId);
+                this.logger.info({ issueKey: issue.issueKey, projectId: item.projectId, reason: "lease_lost_dismissing_inactive_requested_changes_wake" }, "Skipped issue run: lost lease while dismissing inactive requested-changes wake");
+                return;
+            }
+            this.db.issueSessions.setIssueSessionLastWakeReasonWithLease(lease, wake.wakeReason ?? null);
+            this.feed?.publish({
+                level: "info",
+                kind: "stage",
+                issueKey: issue.issueKey,
+                projectId: item.projectId,
+                stage: runType,
+                status: "skipped",
+                summary: inactiveRequestedChangesWakeReason,
+            });
+            this.logger.info({
+                issueKey: issue.issueKey,
+                projectId: item.projectId,
+                runType,
+                reason: "inactive_requested_changes_wake",
+                prReviewState: launchIssue.prReviewState,
+                prState: launchIssue.prState,
+            }, "Skipped issue run: requested-changes wake is no longer active");
+            this.releaseIssueSessionLease(item.projectId, item.issueId);
+            this.wakeDispatcher.dispatchIfWakePending(item.projectId, item.issueId);
+            return;
+        }
         const recoveredLinearActivityContext = await recoverLinearAgentActivityContext({
             linearProvider: this.linearProvider,
             projectId: issue.projectId,
@@ -506,6 +542,18 @@ export class RunOrchestrator {
     async resolveRequestedChangesWakeContext(issue, runType, context) {
         return await this.runCompletionPolicy.resolveRequestedChangesWakeContext(issue, runType, context);
     }
+    resolveInactiveRequestedChangesWakeReason(issue, runType, context) {
+        if (runType !== "review_fix" || context?.branchUpkeepRequired === true) {
+            return undefined;
+        }
+        if (issue.prState && issue.prState !== "open") {
+            return `Skipping requested-changes run because PR #${issue.prNumber ?? "unknown"} is ${issue.prState}`;
+        }
+        if (issue.prReviewState && issue.prReviewState !== "changes_requested") {
+            return `Skipping requested-changes run because PR #${issue.prNumber ?? "unknown"} review state is ${issue.prReviewState}`;
+        }
+        return undefined;
+    }
     async readThreadWithRetry(threadId, maxRetries = 3) {
         let lastError;
         for (let attempt = 0; attempt < maxRetries; attempt++) {

package/dist/run-wake-planner.js

@@ -1,4 +1,5 @@
 import { getCiRepairBudget, getQueueRepairBudget, getReviewFixBudget, } from "./run-budgets.js";
+import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
 export class RunWakePlanner {
     db;
     constructor(db) {
@@ -19,6 +20,7 @@ export class RunWakePlanner {
     appendWakeEventWithLease(lease, issue, runType, context, dedupeScope) {
         let eventType;
         let dedupeKey;
+        let eventContext = context;
         if (runType === "queue_repair") {
             eventType = "merge_steward_incident";
             dedupeKey = `${dedupeScope ?? "wake"}:queue_repair:${issue.linearIssueId}:${issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown-sha"}`;
@@ -29,7 +31,17 @@ export class RunWakePlanner {
         }
         else if (runType === "review_fix" || runType === "branch_upkeep") {
             eventType = "review_changes_requested";
-            dedupeKey = `${dedupeScope ?? "wake"}:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`;
+            const identity = buildRequestedChangesWakeIdentity({
+                linearIssueId: issue.linearIssueId,
+                runType,
+                headSha: issue.prHeadSha,
+            });
+            dedupeKey = identity.dedupeKey;
+            eventContext = {
+                ...context,
+                requestedChangesCoalesceKey: identity.coalesceKey,
+                ...(identity.headSha ? { requestedChangesHeadSha: identity.headSha } : {}),
+            };
         }
         else {
             eventType = "delegated";
@@ -39,7 +51,7 @@ export class RunWakePlanner {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             eventType,
-            ...(context ? { eventJson: JSON.stringify(context) } : {}),
+            ...(eventContext ? { eventJson: JSON.stringify(eventContext) } : {}),
             dedupeKey,
         }));
     }

package/dist/service-runtime.js

@@ -65,7 +65,7 @@ export class ServiceRuntime {
     }
     getReadiness() {
         return {
-            ready: this.ready && this.codex.isStarted() && this.linearConnected,
+            ready: this.ready && this.codex.isStarted() && this.linearConnected && this.githubAppAuthHealthy,
             codexStarted: this.codex.isStarted(),
             linearConnected: this.linearConnected,
             githubAppAuthHealthy: this.githubAppAuthHealthy,

package/dist/service-startup-recovery.js

@@ -1,6 +1,7 @@
 import { appendDelegationObservedEvent } from "./delegation-audit.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { isResumablePausedLocalWork } from "./paused-issue-state.js";
+import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
 export class ServiceStartupRecovery {
     db;
     linearProvider;
@@ -178,11 +179,28 @@ export class ServiceStartupRecovery {
             ? `startup_recovery:queue_repair:${linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown"}`
             : runType === "ci_repair"
                 ? `startup_recovery:ci_repair:${linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown"}`
-                : `startup_recovery:${runType}:${linearIssueId}:${issue.prHeadSha ?? "unknown"}`;
+                : buildRequestedChangesWakeIdentity({
+                    linearIssueId,
+                    runType,
+                    headSha: issue.prHeadSha,
+                }).dedupeKey;
+        const requestedChangesIdentity = eventType === "review_changes_requested"
+            ? buildRequestedChangesWakeIdentity({
+                linearIssueId,
+                runType: runType === "branch_upkeep" ? "branch_upkeep" : "review_fix",
+                headSha: issue.prHeadSha,
+            })
+            : undefined;
         this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(projectId, linearIssueId, {
             projectId,
             linearIssueId,
             eventType,
+            ...(requestedChangesIdentity ? {
+                eventJson: JSON.stringify({
+                    requestedChangesCoalesceKey: requestedChangesIdentity.coalesceKey,
+                    ...(requestedChangesIdentity.headSha ? { requestedChangesHeadSha: requestedChangesIdentity.headSha } : {}),
+                }),
+            } : {}),
             dedupeKey,
         });
     }

package/dist/service.js

@@ -1,5 +1,5 @@
 import { resolveGitHubAppCredentials, createGitHubAppTokenManager, getGitHubAppPaths, } from "./github-app-token.js";
-import { applyGitHubCliAuthEnv, resolveGhBin } from "./github-cli-auth.js";
+import { applyGitHubCliAuthEnv, resolveGhBin, verifyGitHubCliAuthEnv } from "./github-cli-auth.js";
 import { remediateLeakedBotAuth } from "./github-auth-remediation.js";
 import { GitHubWebhookHandler } from "./github-webhook-handler.js";
 import { IssueQueryService } from "./issue-query-service.js";
@@ -149,8 +149,18 @@ export class PatchRelayService {
             this.runtime.setGithubAppAuthHealthy(ghAuthStatus.healthy, ghAuthStatus.lastRefreshError ?? undefined);
             if (!ghAuthStatus.healthy) {
                 this.logger.error({ ghAuthStatus }, "GitHub App auth is NOT healthy at startup — git/gh operations will fail until a token is minted");
+                throw new Error(`GitHub App auth is not healthy at startup: ${ghAuthStatus.lastRefreshError ?? "no fresh installation token"}`);
             }
             else {
+                try {
+                    await verifyGitHubCliAuthEnv(process.env);
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    this.runtime.setGithubAppAuthHealthy(false, msg);
+                    this.logger.error({ error: msg, ghConfigDir }, "GitHub App auth smoke test failed — service will not accept work");
+                    throw error;
+                }
                 this.logger.info({ installationId: ghAuthStatus.installationId, expiresAt: ghAuthStatus.expiresAt }, "GitHub App auth ready — gh + git authenticate as the bot");
             }
             // Clean up credentials older versions persisted into managed repo configs.

package/infra/patchrelay.service

@@ -16,6 +16,7 @@ WorkingDirectory=/home/your-user
 EnvironmentFile=-/home/your-user/.config/patchrelay/runtime.env
 EnvironmentFile=-/home/your-user/.config/patchrelay/service.env
 Environment=NODE_ENV=production
+Environment=CODEX_HOME=/home/alv/.codex-patchrelay
 Environment=PATCHRELAY_CONFIG=/home/your-user/.config/patchrelay/patchrelay.json
 Environment=PATH=/home/your-user/.local/share/patchrelay/bin:/home/your-user/.local/bin:/usr/local/bin:/usr/bin:/bin
 
@@ -43,7 +44,7 @@ PrivateTmp=true
 PrivateMounts=true
 ProtectSystem=strict
 ProtectHome=false
-ReadWritePaths=/home/your-user/.config/patchrelay /home/your-user/.local/state/patchrelay /home/your-user/.local/share/patchrelay
+ReadWritePaths=/home/your-user/.config/patchrelay /home/your-user/.local/state/patchrelay /home/your-user/.local/share/patchrelay /home/alv/.codex-patchrelay
 
 # PatchRelay runs as your real user so Codex inherits your existing git,
 # SSH, and local tool permissions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.73.4",
+  "version": "0.74.1",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -31,17 +31,17 @@
   "dependencies": {
     "fastify": "^5.8.5",
     "fastify-raw-body": "^5.0.0",
-    "ink": "^7.0.1",
+    "ink": "^7.0.4",
     "pino": "^10.3.1",
     "pino-logfmt": "^1.1.4",
-    "react": "^19.2.5",
-    "zod": "^4.3.6"
+    "react": "^19.2.6",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0",
-    "@types/react": "^19.2.14",
-    "@typescript/native-preview": "7.0.0-dev.20260427.1",
-    "oxlint": "^1.62.0"
+    "@types/node": "^25.9.1",
+    "@types/react": "^19.2.15",
+    "@typescript/native-preview": "7.0.0-dev.20260527.1",
+    "oxlint": "^1.67.0"
   },
   "scripts": {
     "dev": "node --watch --experimental-transform-types src/index.ts",