patchrelay 0.73.3 → 0.74.0

package/dist/agent-input-service.js

@@ -1,6 +1,7 @@
 import { buildFollowupStatusActivity, buildNonActionableFollowupActivity, buildPromptDeliveryFailedActivity, buildPromptDeliveredThought, } from "./linear-session-reporting.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { extractLatestAssistantSummary } from "./issue-session-events.js";
+import { dirtyWorktreeEventPayload, inspectGitWorktreeStatus } from "./git-worktree-status.js";
 export class AgentInputService {
     db;
     codex;
@@ -211,6 +212,9 @@ export class AgentInputService {
         }) ?? issue;
     }
     async stopActiveRun(issue, run, body, source) {
+        const worktreeStatus = issue.worktreePath ? inspectGitWorktreeStatus(issue.worktreePath) : undefined;
+        const dirtyPayload = worktreeStatus ? dirtyWorktreeEventPayload(worktreeStatus) : undefined;
+        const dirtySummary = typeof dirtyPayload?.summary === "string" ? dirtyPayload.summary : undefined;
         if (run.threadId && run.turnId) {
             try {
                 await this.codex.steerTurn({
@@ -222,7 +226,12 @@ export class AgentInputService {
             catch (error) {
                 this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to steer Codex turn for stop request");
             }
-            this.db.runs.finishRun(run.id, { status: "released", threadId: run.threadId, turnId: run.turnId });
+            this.db.runs.finishRun(run.id, {
+                status: "released",
+                threadId: run.threadId,
+                turnId: run.turnId,
+                failureReason: dirtySummary ? `Operator stopped run; ${dirtySummary}` : "Operator stopped run",
+            });
         }
         this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
@@ -232,7 +241,7 @@ export class AgentInputService {
         });
         this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
             eventType: "stop_requested",
-            eventJson: JSON.stringify({ body, source }),
+            eventJson: JSON.stringify({ body, source, ...dirtyPayload }),
         });
         this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
         this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.73.3",
-  "commit": "3342a5c6bbc1",
-  "builtAt": "2026-05-26T13:58:45.864Z"
+  "version": "0.74.0",
+  "commit": "d04d91223dec",
+  "builtAt": "2026-05-28T18:16:54.428Z"
 }

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/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/git-worktree-status.js

@@ -0,0 +1,69 @@
+import { spawnSync } from "node:child_process";
+const UNMERGED_CODES = new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
+function parsePorcelainPath(line) {
+    const raw = line.slice(3).trim();
+    const renameSeparator = " -> ";
+    const renamed = raw.includes(renameSeparator) ? raw.slice(raw.indexOf(renameSeparator) + renameSeparator.length) : raw;
+    return renamed.replace(/^"|"$/g, "");
+}
+function hasGitPath(worktreePath, pathName) {
+    const result = spawnSync("git", ["-C", worktreePath, "rev-parse", "--git-path", pathName], { encoding: "utf8" });
+    if (result.status !== 0)
+        return false;
+    const resolved = result.stdout.trim();
+    if (!resolved)
+        return false;
+    return spawnSync("test", ["-f", resolved]).status === 0;
+}
+export function inspectGitWorktreeStatus(worktreePath) {
+    const result = spawnSync("git", ["-C", worktreePath, "status", "--porcelain=v1", "-uall"], {
+        encoding: "utf8",
+    });
+    if (result.status !== 0) {
+        return {
+            dirty: true,
+            mergeInProgress: false,
+            unmergedPaths: [],
+            changedPaths: [],
+            summary: `Unable to inspect worktree: ${(result.stderr || result.stdout).trim() || "git status failed"}`,
+        };
+    }
+    const lines = result.stdout.split(/\r?\n/).filter(Boolean);
+    const changedPaths = lines.map(parsePorcelainPath);
+    const unmergedPaths = lines
+        .filter((line) => UNMERGED_CODES.has(line.slice(0, 2)) || line.slice(0, 2).includes("U"))
+        .map(parsePorcelainPath);
+    const mergeInProgress = hasGitPath(worktreePath, "MERGE_HEAD")
+        || hasGitPath(worktreePath, "REBASE_HEAD")
+        || hasGitPath(worktreePath, "CHERRY_PICK_HEAD")
+        || hasGitPath(worktreePath, "REVERT_HEAD");
+    const dirty = lines.length > 0 || mergeInProgress;
+    const summary = dirty
+        ? unmergedPaths.length > 0
+            ? `Worktree has unresolved merge conflicts: ${unmergedPaths.join(", ")}`
+            : changedPaths.length > 0
+                ? `Worktree has uncommitted changes: ${changedPaths.slice(0, 12).join(", ")}${changedPaths.length > 12 ? ", ..." : ""}`
+                : "Worktree has an unfinished git operation"
+        : undefined;
+    return {
+        dirty,
+        mergeInProgress,
+        unmergedPaths,
+        changedPaths,
+        ...(summary ? { summary } : {}),
+    };
+}
+export function isRepairRunType(runType) {
+    return runType === "review_fix" || runType === "branch_upkeep" || runType === "ci_repair" || runType === "queue_repair";
+}
+export function dirtyWorktreeEventPayload(status) {
+    if (!status.dirty)
+        return undefined;
+    return {
+        dirtyWorktree: true,
+        mergeInProgress: status.mergeInProgress,
+        unmergedPaths: status.unmergedPaths,
+        changedPaths: status.changedPaths,
+        summary: status.summary,
+    };
+}

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/prompting/patchrelay.js

@@ -563,6 +563,10 @@ function buildPublicationContract(runType, issueClass, context) {
         "Restore and publish on the existing PR branch: commit and push the same branch.",
         "Do not open a new PR.",
         "A PR-less stop is not a successful outcome for a repair run unless a genuine external blocker prevents any correct push.",
+        "After pushing a new head, stop and report the pushed commit. Do not poll or watch GitHub for CI, review, mergeability, review-quill, merge-steward, approval, or merge completion.",
+        "Do not run blocking wait commands such as `gh pr checks --watch`, `gh pr view` polling loops, `review-quill pr status --wait`, `merge-steward pr status --wait`, or `gh pr merge` from the agent turn.",
+        "PatchRelay receives GitHub webhooks for check, review, and base-branch changes; those events will re-enter automation if more work is needed.",
+        "If the issue text asks you to watch CI, wait for approval, or merge after checks pass, treat that as PatchRelay service responsibility rather than agent-turn work.",
         "",
         ...(requiresFreshQueueHead
             ? [

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-finalizer.js

@@ -3,6 +3,7 @@ import { buildRunCompletedActivity, buildRunFailureActivity } from "./linear-ses
 import { handleNoPrCompletionCheck } from "./no-pr-completion-check.js";
 import { resolveCompletedRunState } from "./run-completion-policy.js";
 import { computeChangeIdentityFromWorktree } from "./change-identity.js";
+import { inspectGitWorktreeStatus, isRepairRunType } from "./git-worktree-status.js";
 function parseEventJson(eventJson) {
     if (!eventJson)
         return undefined;
@@ -273,6 +274,16 @@ export class RunFinalizer {
         // exists. Keeping the parameter would be redundant.
         this.clearProgressAndRelease(params.run);
     }
+    verifyRepairWorktreeClean(run, issue) {
+        if (!isRepairRunType(run.runType) || !issue.worktreePath)
+            return undefined;
+        const status = inspectGitWorktreeStatus(issue.worktreePath);
+        if (!status.dirty)
+            return undefined;
+        return status.summary
+            ? `Repair run finished with a dirty worktree; ${status.summary}`
+            : "Repair run finished with a dirty worktree";
+    }
     async finalizeCompletedRun(params) {
         const { run, issue, thread, threadId } = params;
         // Plan §4.4: a run flagged shouldNotPublish was deliberately
@@ -291,6 +302,19 @@ export class RunFinalizer {
         const trackedIssue = this.db.issueToTrackedIssue(issue);
         const report = buildStageReport({ ...run, status: "completed" }, trackedIssue, thread, countEventMethods(this.db.runs.listThreadEvents(run.id)));
         const freshIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        const dirtyRepairWorktreeError = this.verifyRepairWorktreeClean(run, freshIssue);
+        if (dirtyRepairWorktreeError) {
+            this.failRunAndClear(run, dirtyRepairWorktreeError, "escalated");
+            this.syncFailureOutcome({
+                run,
+                fallbackIssue: freshIssue,
+                message: dirtyRepairWorktreeError,
+                level: "error",
+                status: "dirty_repair_worktree",
+                summary: dirtyRepairWorktreeError,
+            });
+            return;
+        }
         const verifiedRepairError = await this.completionPolicy.verifyReactiveRunAdvancedBranch(run, freshIssue);
         if (verifiedRepairError) {
             const holdState = params.resolveRecoverableRunState(freshIssue) ?? "failed";

package/dist/run-orchestrator.js

@@ -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-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/status-note.js

@@ -7,10 +7,18 @@ function clean(value) {
 function eventStatusNote(event) {
     if (!event)
         return undefined;
+    const payload = event.eventJson ? parseEventJson(event.eventJson) : undefined;
+    const dirtySummary = typeof payload?.summary === "string" && payload.dirtyWorktree === true
+        ? payload.summary
+        : undefined;
     switch (event.eventType) {
         case "stop_requested":
+            if (dirtySummary)
+                return `Operator stopped the run with dirty worktree: ${dirtySummary}. Use retry or delegate again to resume.`;
             return "Operator stopped the run. Use retry or delegate again to resume.";
         case "undelegated":
+            if (dirtySummary)
+                return `Issue was un-delegated from PatchRelay with dirty worktree: ${dirtySummary}`;
             return "Issue was un-delegated from PatchRelay. Delegate it again to resume.";
         case "issue_removed":
             return "Issue was removed from Linear.";
@@ -22,6 +30,15 @@ function eventStatusNote(event) {
             return undefined;
     }
 }
+function parseEventJson(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function deriveIssueStatusNote(params) {
     const blockedByKeys = (params.blockedByKeys ?? []).filter((value) => value.trim().length > 0);
     if (blockedByKeys.length > 0) {
@@ -61,7 +78,7 @@ export function deriveIssueStatusNote(params) {
                 note = failureSummary ?? sessionSummary ?? latestRunNote;
                 break;
             default:
-                note = sessionSummary ?? latestRunNote ?? failureSummary;
+                note = latestEventNote ?? sessionSummary ?? latestRunNote ?? failureSummary;
                 break;
         }
     }

package/dist/webhooks/agent-session-handler.js

@@ -1,6 +1,7 @@
 import { buildAgentSessionPlanForIssue, } from "../agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "../agent-session-presentation.js";
 import { buildAlreadyRunningThought, buildAgentSessionAcknowledgementThought, buildBlockedDelegationActivity, buildDelegationThought, buildStopConfirmationActivity, } from "../linear-session-reporting.js";
+import { dirtyWorktreeEventPayload, inspectGitWorktreeStatus } from "../git-worktree-status.js";
 import { resolveProject, triggerEventAllowed } from "../project-resolution.js";
 const PATCHRELAY_AGENT_ACTIVITY_TYPES = new Set([
     "action",
@@ -154,6 +155,12 @@ export class AgentSessionHandler {
     async handleStopSignal(params) {
         const issueId = params.normalized.issue.id;
         const sessionId = params.normalized.agentSession.id;
+        const storedIssue = this.db.issues.getIssue(params.project.id, issueId);
+        const worktreeStatus = storedIssue?.worktreePath
+            ? inspectGitWorktreeStatus(storedIssue.worktreePath)
+            : undefined;
+        const dirtyPayload = worktreeStatus ? dirtyWorktreeEventPayload(worktreeStatus) : undefined;
+        const dirtySummary = typeof dirtyPayload?.summary === "string" ? dirtyPayload.summary : undefined;
         if (params.activeRun?.threadId && params.activeRun.turnId) {
             try {
                 await this.codex.steerTurn({
@@ -165,7 +172,12 @@ export class AgentSessionHandler {
             catch (error) {
                 this.logger.warn({ issueKey: params.trackedIssue?.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to steer Codex turn for stop signal");
             }
-            this.db.runs.finishRun(params.activeRun.id, { status: "released", threadId: params.activeRun.threadId, turnId: params.activeRun.turnId });
+            this.db.runs.finishRun(params.activeRun.id, {
+                status: "released",
+                threadId: params.activeRun.threadId,
+                turnId: params.activeRun.turnId,
+                failureReason: dirtySummary ? `Stop signal received; ${dirtySummary}` : "Stop signal received",
+            });
         }
         this.db.issueSessions.upsertIssueRespectingActiveLease(params.project.id, issueId, {
             projectId: params.project.id,
@@ -178,6 +190,7 @@ export class AgentSessionHandler {
             projectId: params.project.id,
             linearIssueId: issueId,
             eventType: "stop_requested",
+            ...(dirtyPayload ? { eventJson: JSON.stringify(dirtyPayload) } : {}),
             dedupeKey: `stop_requested:${issueId}`,
         });
         this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(params.project.id, issueId);
@@ -188,7 +201,7 @@ export class AgentSessionHandler {
             projectId: params.project.id,
             issueKey: params.trackedIssue?.issueKey,
             status: "stopped",
-            summary: "Stop signal received - work halted",
+            summary: dirtySummary ? `Stop signal received - work halted with dirty worktree: ${dirtySummary}` : "Stop signal received - work halted",
         });
         const updatedIssue = this.db.issues.getIssue(params.project.id, issueId);
         await this.publishAgentActivity(params.linear, sessionId, buildStopConfirmationActivity());

package/dist/webhooks/desired-stage-recorder.js

@@ -6,6 +6,7 @@ import { syncIssueDependencies } from "./issue-dependency-sync.js";
 import { resolveLinkedPrAdoption } from "./linked-pr-adoption.js";
 import { buildOperatorRetryEvent } from "../operator-retry-event.js";
 import { planIssueWebhookWorkflow } from "./issue-webhook-workflow-planner.js";
+import { dirtyWorktreeEventPayload, inspectGitWorktreeStatus } from "../git-worktree-status.js";
 export class DesiredStageRecorder {
     db;
     linearProvider;
@@ -74,6 +75,15 @@ export class DesiredStageRecorder {
             incomingAgentSessionId,
             childIssueCount,
         });
+        const releaseWorktreeStatus = workflowPlan.effectiveRunRelease.release && activeRun && existingIssue?.worktreePath
+            ? inspectGitWorktreeStatus(existingIssue.worktreePath)
+            : undefined;
+        const releaseReason = workflowPlan.effectiveRunRelease.reason
+            ? releaseWorktreeStatus?.dirty && releaseWorktreeStatus.summary
+                ? `${workflowPlan.effectiveRunRelease.reason}; ${releaseWorktreeStatus.summary}`
+                : workflowPlan.effectiveRunRelease.reason
+            : undefined;
+        const dirtyWorktreePayload = releaseWorktreeStatus ? dirtyWorktreeEventPayload(releaseWorktreeStatus) : undefined;
         const commitIssueUpdate = () => {
             const record = this.db.issues.upsertIssue({
                 projectId: params.project.id,
@@ -94,8 +104,8 @@ export class DesiredStageRecorder {
                 delegatedToPatchRelay: delegated,
                 ...workflowPlan.resolvedIssueUpdate,
             });
-            if (workflowPlan.effectiveRunRelease.release && activeRun && workflowPlan.effectiveRunRelease.reason) {
-                this.db.runs.finishRun(activeRun.id, { status: "released", failureReason: workflowPlan.effectiveRunRelease.reason });
+            if (workflowPlan.effectiveRunRelease.release && activeRun && releaseReason) {
+                this.db.runs.finishRun(activeRun.id, { status: "released", failureReason: releaseReason });
             }
             return record;
         };
@@ -119,6 +129,11 @@ export class DesiredStageRecorder {
                 projectId: params.project.id,
                 linearIssueId: normalizedIssue.id,
                 eventType: "undelegated",
+                ...(dirtyWorktreePayload
+                    ? {
+                        eventJson: JSON.stringify(dirtyWorktreePayload),
+                    }
+                    : {}),
                 dedupeKey: `undelegated:${normalizedIssue.id}`,
             });
             this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(params.project.id, normalizedIssue.id);
@@ -130,9 +145,11 @@ export class DesiredStageRecorder {
                 projectId: params.project.id,
                 stage: issue.factoryState,
                 status: "un_delegated",
-                summary: issue.factoryState === "awaiting_input"
-                    ? "Issue un-delegated from PatchRelay"
-                    : `Issue un-delegated from PatchRelay; ${issue.factoryState} is now paused`,
+                summary: releaseWorktreeStatus?.dirty && releaseWorktreeStatus.summary
+                    ? `Issue un-delegated from PatchRelay with dirty worktree: ${releaseWorktreeStatus.summary}`
+                    : issue.factoryState === "awaiting_input"
+                        ? "Issue un-delegated from PatchRelay"
+                        : `Issue un-delegated from PatchRelay; ${issue.factoryState} is now paused`,
             });
         }
         else if (workflowPlan.blockerPausedImplementation) {

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.3",
+  "version": "0.74.0",
   "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",