patchrelay 0.52.6 → 0.53.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.52.6",
-  "commit": "cc8a389260f0",
-  "builtAt": "2026-04-22T23:52:25.456Z"
+  "version": "0.53.1",
+  "commit": "6cfb95653641",
+  "builtAt": "2026-04-24T01:17:31.633Z"
 }

package/dist/cli/commands/issues.js

@@ -2,7 +2,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { getRunTypeFlag } from "../args.js";
 import { CliUsageError } from "../errors.js";
 import { formatJson } from "../formatters/json.js";
-import { formatAudit, formatClose, formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatTranscriptSource, formatWorktree } from "../formatters/text.js";
+import { formatAudit, formatClose, formatInspect, formatList, formatLive, formatOpen, formatPrompt, formatRetry, formatSessionHistory, formatTranscriptSource, formatWorktree } from "../formatters/text.js";
 import { buildOpenCommand } from "../interactive.js";
 import { writeOutput } from "../output.js";
 export async function handleIssueCommand(params) {
@@ -40,6 +40,8 @@ export async function handleIssueCommand(params) {
             return await handleAuditCommand(nested);
         case "transcript-source":
             return await handleTranscriptSourceCommand(nested);
+        case "prompt":
+            return await handlePromptCommand(nested);
         case "retry":
             return await handleRetryCommand(nested);
         case "close":
@@ -190,6 +192,20 @@ export async function handleRetryCommand(params) {
     writeOutput(params.stdout, params.json ? formatJson(result) : formatRetry(result));
     return 0;
 }
+export async function handlePromptCommand(params) {
+    const issueKey = params.commandArgs[0];
+    if (!issueKey) {
+        throw new Error("prompt requires <issueKey>.");
+    }
+    const text = params.commandArgs.slice(1).join(" ").trim();
+    if (!text) {
+        throw new Error("prompt requires <text>.");
+    }
+    const result = await params.data.promptIssue(issueKey, text);
+    const payload = { issueKey, ...result };
+    writeOutput(params.stdout, params.json ? formatJson(payload) : formatPrompt(payload));
+    return 0;
+}
 export async function handleCloseCommand(params) {
     const issueKey = params.commandArgs[0];
     if (!issueKey) {

package/dist/cli/formatters/text.js

@@ -84,6 +84,15 @@ export function formatRetry(result) {
         .filter(Boolean)
         .join("\n")}\n`;
 }
+export function formatPrompt(result) {
+    return `${[
+        value("Issue", result.issueKey),
+        value("Delivered", result.delivered ? "yes" : "no"),
+        result.queued ? value("Queued", "yes") : undefined,
+    ]
+        .filter(Boolean)
+        .join("\n")}\n`;
+}
 export function formatAudit(result) {
     const lines = [
         `${result.issue.issueKey ?? result.issue.linearIssueId}${result.issue.currentLinearState ? `  ${result.issue.currentLinearState}` : ""}`,

package/dist/cli/help.js

@@ -39,6 +39,7 @@ export function rootHelpText() {
         "  issue open <issueKey> [--print] [--json]                Open Codex in the issue worktree",
         "  issue sessions <issueKey> [--json]                      Show recorded Codex app-server sessions for one issue",
         "  issue transcript-source <issueKey> [--run <id>] [--json]  Show the raw Codex session file for one issue run",
+        "  issue prompt <issueKey> <text> [--json]                 Send operator guidance to the active or next run",
         "  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",
@@ -154,6 +155,7 @@ export function issueHelpText() {
         "  open <issueKey>                 Open Codex in the issue worktree",
         "  sessions <issueKey>             Show recorded Codex app-server sessions",
         "  transcript-source <issueKey>    Show the raw Codex session file for one issue run",
+        "  prompt <issueKey> <text>        Send operator guidance to the active or next run",
         "  retry <issueKey>                Requeue a run",
         "  close <issueKey>                Force-close a stuck issue",
         "",
@@ -163,6 +165,7 @@ export function issueHelpText() {
         "  patchrelay issue watch USE-54",
         "  patchrelay issue sessions USE-54",
         "  patchrelay issue transcript-source USE-54",
+        "  patchrelay issue prompt USE-54 \"rebuild this branch cleanly from main\"",
         "  patchrelay close USE-54 --reason \"already handled manually\"",
     ].join("\n");
 }

package/dist/cli/index.js

@@ -67,6 +67,9 @@ function validateFlags(command, commandArgs, parsed) {
                 case "transcript-source":
                     assertKnownFlags(parsed, "issue", ["run", "json"]);
                     return;
+                case "prompt":
+                    assertKnownFlags(parsed, "issue", ["json"]);
+                    return;
                 case "retry":
                     assertKnownFlags(parsed, "issue", ["run-type", "reason", "json"]);
                     return;

package/dist/cli/operator-client.js

@@ -15,6 +15,15 @@ export class CliOperatorApiClient {
         }
         return await this.requestJson(`/api/oauth/linear/state/${encodeURIComponent(state)}`);
     }
+    async promptIssue(issueKey, text) {
+        if (!issueKey.trim()) {
+            throw new Error("Issue key is required.");
+        }
+        if (!text.trim()) {
+            throw new Error("Prompt text is required.");
+        }
+        return await this.requestJson(`/api/issues/${encodeURIComponent(issueKey)}/prompt`, undefined, { method: "POST", body: { text } });
+    }
     async listInstallations() {
         return await this.requestJson("/api/installations");
     }

package/dist/codex-app-server.js

@@ -45,6 +45,7 @@ export class CodexAppServerClient extends EventEmitter {
     stdoutBuffer = "";
     started = false;
     stopping = false;
+    startPromise;
     constructor(config, logger, spawnProcess = spawn) {
         super();
         this.config = config;
@@ -68,76 +69,16 @@ export class CodexAppServerClient extends EventEmitter {
         if (this.started) {
             return;
         }
-        this.stopping = false;
-        const launch = resolveCodexAppServerLaunch(this.config);
-        this.logger.info({ command: launch.command, args: launch.args }, "Starting Codex app-server");
-        this.child = this.spawnProcess(launch.command, launch.args, {
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        this.child.stdin.on("error", (error) => {
-            this.logger.error({ error: sanitizeDiagnosticText(error.message) }, "Codex app-server stdin error");
-        });
-        this.child.stdout.on("error", (error) => {
-            this.logger.error({ error: sanitizeDiagnosticText(error.message) }, "Codex app-server stdout error");
-        });
-        this.child.stderr.on("error", (error) => {
-            this.logger.error({ error: sanitizeDiagnosticText(error.message) }, "Codex app-server stderr error");
-        });
-        this.child.stderr.on("data", (chunk) => {
-            const line = chunk.toString().trim();
-            if (line) {
-                this.logger.warn({ output: sanitizeDiagnosticText(line) }, "Codex app-server stderr");
-            }
-        });
-        this.child.on("error", (error) => {
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.logger.error({
-                error: sanitizeDiagnosticText(err.message),
-                pendingRequestCount: this.pending.size,
-            }, "Codex app-server process errored");
-            this.rejectAllPending(err);
-        });
-        this.child.on("close", (code, signal) => {
-            this.started = false;
-            const log = this.stopping ? this.logger.info.bind(this.logger) : this.logger.warn.bind(this.logger);
-            log({
-                code: code ?? 1,
-                signal: signal ?? null,
-                pendingRequestCount: this.pending.size,
-            }, this.stopping ? "Codex app-server stopped" : "Codex app-server exited");
-            this.stopping = false;
-            this.rejectAllPending(new Error(`Codex app-server exited with code ${code ?? 1}`));
-        });
-        this.child.stdout.on("data", (chunk) => {
-            this.stdoutBuffer += chunk.toString("utf8");
-            if (this.stdoutBuffer.length > 50 * 1024 * 1024) {
-                this.logger.error({ bufferSize: this.stdoutBuffer.length }, "Codex app-server stdout buffer exceeded 50 MB — killing process");
-                this.stdoutBuffer = "";
-                this.rejectAllPending(new Error("Codex app-server stdout buffer overflow"));
-                this.child?.kill("SIGTERM");
-                return;
-            }
-            this.drainMessages();
-        });
-        const initializeResponse = await this.sendRequest("initialize", {
-            clientInfo: {
-                name: "patchrelay",
-                title: "PatchRelay",
-                version: "0.1.0",
-            },
-            capabilities: {
-                experimentalApi: true,
-            },
-        });
-        const serverInfo = initializeResponse && typeof initializeResponse === "object" && "serverInfo" in initializeResponse
-            ? initializeResponse.serverInfo
-            : undefined;
-        this.logger.info({
-            serverName: typeof serverInfo?.name === "string" ? serverInfo.name : undefined,
-            serverVersion: typeof serverInfo?.version === "string" ? serverInfo.version : undefined,
-        }, "Connected to Codex app-server");
-        this.sendNotification("initialized");
-        this.started = true;
+        if (this.startPromise) {
+            return await this.startPromise;
+        }
+        this.startPromise = this.startInternal();
+        try {
+            await this.startPromise;
+        }
+        finally {
+            this.startPromise = undefined;
+        }
     }
     async stop() {
         const child = this.child;
@@ -276,9 +217,7 @@ export class CodexAppServerClient extends EventEmitter {
         });
     }
     async sendRequest(method, params) {
-        if (!this.child?.stdin) {
-            throw new Error("Codex app-server is not running");
-        }
+        await this.ensureRunningForRequest(method);
         const id = this.nextRequestId++;
         const requestTimeoutMs = this.config.requestTimeoutMs ?? CodexAppServerClient.DEFAULT_REQUEST_TIMEOUT_MS;
         const promise = new Promise((resolve, reject) => {
@@ -316,6 +255,93 @@ export class CodexAppServerClient extends EventEmitter {
             throw err;
         });
     }
+    async startInternal() {
+        this.stopping = false;
+        this.stdoutBuffer = "";
+        const launch = resolveCodexAppServerLaunch(this.config);
+        this.logger.info({ command: launch.command, args: launch.args }, "Starting Codex app-server");
+        this.child = this.spawnProcess(launch.command, launch.args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child.stdin.on("error", (error) => {
+            this.logger.error({ error: sanitizeDiagnosticText(error.message) }, "Codex app-server stdin error");
+        });
+        this.child.stdout.on("error", (error) => {
+            this.logger.error({ error: sanitizeDiagnosticText(error.message) }, "Codex app-server stdout error");
+        });
+        this.child.stderr.on("error", (error) => {
+            this.logger.error({ error: sanitizeDiagnosticText(error.message) }, "Codex app-server stderr error");
+        });
+        this.child.stderr.on("data", (chunk) => {
+            const line = chunk.toString().trim();
+            if (line) {
+                this.logger.warn({ output: sanitizeDiagnosticText(line) }, "Codex app-server stderr");
+            }
+        });
+        this.child.on("error", (error) => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error({
+                error: sanitizeDiagnosticText(err.message),
+                pendingRequestCount: this.pending.size,
+            }, "Codex app-server process errored");
+            this.rejectAllPending(err);
+        });
+        this.child.on("close", (code, signal) => {
+            this.started = false;
+            this.child = undefined;
+            this.stdoutBuffer = "";
+            const log = this.stopping ? this.logger.info.bind(this.logger) : this.logger.warn.bind(this.logger);
+            log({
+                code: code ?? 1,
+                signal: signal ?? null,
+                pendingRequestCount: this.pending.size,
+            }, this.stopping ? "Codex app-server stopped" : "Codex app-server exited");
+            this.stopping = false;
+            this.rejectAllPending(new Error(`Codex app-server exited with code ${code ?? 1}`));
+        });
+        this.child.stdout.on("data", (chunk) => {
+            this.stdoutBuffer += chunk.toString("utf8");
+            if (this.stdoutBuffer.length > 50 * 1024 * 1024) {
+                this.logger.error({ bufferSize: this.stdoutBuffer.length }, "Codex app-server stdout buffer exceeded 50 MB — killing process");
+                this.stdoutBuffer = "";
+                this.rejectAllPending(new Error("Codex app-server stdout buffer overflow"));
+                this.child?.kill("SIGTERM");
+                return;
+            }
+            this.drainMessages();
+        });
+        const initializeResponse = await this.sendRequest("initialize", {
+            clientInfo: {
+                name: "patchrelay",
+                title: "PatchRelay",
+                version: "0.1.0",
+            },
+            capabilities: {
+                experimentalApi: true,
+            },
+        });
+        const serverInfo = initializeResponse && typeof initializeResponse === "object" && "serverInfo" in initializeResponse
+            ? initializeResponse.serverInfo
+            : undefined;
+        this.logger.info({
+            serverName: typeof serverInfo?.name === "string" ? serverInfo.name : undefined,
+            serverVersion: typeof serverInfo?.version === "string" ? serverInfo.version : undefined,
+        }, "Connected to Codex app-server");
+        this.sendNotification("initialized");
+        this.started = true;
+    }
+    async ensureRunningForRequest(method) {
+        if (this.child?.stdin) {
+            return;
+        }
+        if (method !== "initialize") {
+            this.logger.warn({ method }, "Codex app-server is unavailable before request; restarting");
+        }
+        await this.start();
+        if (!this.child?.stdin) {
+            throw new Error("Codex app-server is not running");
+        }
+    }
     writeMessage(message) {
         if (!this.child?.stdin) {
             throw new Error("Codex app-server stdin is unavailable");

package/dist/prompting/patchrelay.js

@@ -306,6 +306,7 @@ function buildCiRepairContext(context) {
         "Goal: restore CI readiness and push a branch that is likely to pass the next full CI run.",
         "Before changing code or config, reproduce the failure on the exact failing head or identify the concrete log signature that justifies the fix.",
         "If the exact failing head does not reproduce locally and the logs do not support a scoped fix, prefer a rerun-only repair over speculative branch changes.",
+        "Do not use broad revert stacks or repo-wide package-manager/workflow/docs cleanups as a repair tactic; stay on the failing incident only.",
         snapshot?.gateCheckName ? `Gate check: ${String(snapshot.gateCheckName)}` : "",
         snapshot?.gateCheckStatus ? `Gate status: ${String(snapshot.gateCheckStatus)}` : "",
         snapshot?.settledAt ? `Settled at: ${String(snapshot.settledAt)}` : "",
@@ -510,6 +511,9 @@ function buildPrePushSelfReviewSection(target, runType) {
         lines.push("Name 2-4 concrete invariants most likely to regress in the touched flow, confirm which file or path enforces each one, and verify at least one adjacent path you did not edit directly.", "If you changed schema, enums, shared vocabulary, normalization helpers, or compatibility mappings, inspect the main read/write paths that can bypass the new abstraction and verify one legacy-flow and one new-flow case before publishing.");
     }
     lines.push("Do not widen scope for optional cleanup. If the issue explicitly allows a non-PR outcome, complete that outcome clearly; otherwise publish before stopping.");
+    if (runType === "review_fix" || runType === "branch_upkeep" || runType === "ci_repair" || runType === "queue_repair") {
+        lines.push("On reactive repair runs, do not publish broad revert stacks or unrelated workflow/package-manager/docs churn. If that seems necessary, stop and surface the blocker instead.");
+    }
     return lines;
 }
 function buildPublicationContract(runType, issueClass) {

package/dist/reactive-publish-delta.js

@@ -0,0 +1,30 @@
+import { execCommand, safeJsonParse } from "./utils.js";
+export async function readReactivePublishDelta(repoFullName, baseHeadSha, publishedHeadSha) {
+    const { stdout, exitCode } = await execCommand("gh", [
+        "api",
+        `repos/${repoFullName}/compare/${baseHeadSha}...${publishedHeadSha}`,
+    ], { timeoutMs: 10_000 });
+    if (exitCode !== 0) {
+        return undefined;
+    }
+    const payload = safeJsonParse(stdout);
+    if (!payload) {
+        return undefined;
+    }
+    const changedFiles = (payload.files ?? [])
+        .map((entry) => entry.filename?.trim())
+        .filter((entry) => Boolean(entry));
+    const commitSubjects = (payload.commits ?? [])
+        .map((entry) => firstLine(entry.commit?.message))
+        .filter((entry) => Boolean(entry));
+    return {
+        changedFiles,
+        commitSubjects,
+    };
+}
+function firstLine(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.split(/\r?\n/, 1)[0]?.trim() || undefined;
+}

package/dist/reactive-run-policy.js

@@ -1,5 +1,21 @@
 import { buildReviewFixBranchUpkeepContext, isDirtyMergeStateStatus, isRequestedChangesRunType, readReactivePrSnapshot, } from "./reactive-pr-state.js";
+import { readReactivePublishDelta } from "./reactive-publish-delta.js";
 import { readLatestRequestedChangesReviewContext } from "./remote-pr-review.js";
+const REACTIVE_SCOPE_RISK_PREFIXES = [
+    ".github/workflows/",
+    "scripts/bootstrap-worktree.",
+];
+const REACTIVE_SCOPE_RISK_EXACT_PATHS = new Set([
+    ".patchrelay/hooks/prepare-worktree",
+    "AGENTS.md",
+    "CLAUDE.md",
+    "DEV_SETUP.md",
+    "IMPLEMENTATION_WORKFLOW.md",
+    "REVIEW_WORKFLOW.md",
+    "package.json",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+]);
 export class ReactiveRunPolicy {
     config;
     db;
@@ -73,6 +89,57 @@ export class ReactiveRunPolicy {
             return undefined;
         }
     }
+    async verifyReactiveRunStayedInScope(run, issue) {
+        if (run.runType !== "ci_repair" && run.runType !== "review_fix" && run.runType !== "queue_repair" && run.runType !== "branch_upkeep") {
+            return undefined;
+        }
+        if (!issue.prNumber || issue.prState !== "open") {
+            return undefined;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        const repoFullName = project?.github?.repoFullName;
+        const baselineHeadSha = resolveReactiveBaselineHead(run, issue);
+        if (!repoFullName || !baselineHeadSha) {
+            return undefined;
+        }
+        try {
+            const snapshot = await readReactivePrSnapshot(this.config, run.projectId, issue.prNumber);
+            if (!snapshot || snapshot.prState !== "open" || !snapshot.headSha || snapshot.headSha === baselineHeadSha) {
+                return undefined;
+            }
+            const delta = await readReactivePublishDelta(repoFullName, baselineHeadSha, snapshot.headSha);
+            if (!delta) {
+                return undefined;
+            }
+            const revertSubjects = delta.commitSubjects.filter((subject) => /^Revert\s+"/.test(subject));
+            if (revertSubjects.length > 0) {
+                return [
+                    `Reactive ${run.runType.replace("_", "-")} for PR #${issue.prNumber} introduced revert commit(s) after ${baselineHeadSha.slice(0, 8)}.`,
+                    `PatchRelay must use scoped edits or a clean reroll instead of revert-stack cleanup.`,
+                    `Reverts: ${revertSubjects.slice(0, 3).join("; ")}`,
+                ].join(" ");
+            }
+            if (run.runType === "review_fix" || run.runType === "ci_repair") {
+                const riskyFiles = delta.changedFiles.filter(isReactiveScopeRiskPath);
+                if (riskyFiles.length > 0) {
+                    return [
+                        `Reactive ${run.runType.replace("_", "-")} for PR #${issue.prNumber} widened scope after ${baselineHeadSha.slice(0, 8)} by touching repo-meta files.`,
+                        `PatchRelay should stop instead of publishing workflow, package-manager, bootstrap, or docs churn during reactive repair.`,
+                        `Files: ${riskyFiles.slice(0, 6).join(", ")}`,
+                    ].join(" ");
+                }
+            }
+            return undefined;
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to verify reactive publish scope");
+            return undefined;
+        }
+    }
     async refreshIssueAfterReactivePublish(run, issue) {
         if (run.runType !== "ci_repair" && run.runType !== "queue_repair" && !isRequestedChangesRunType(run.runType)) {
             return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
@@ -235,6 +302,19 @@ export class ReactiveRunPolicy {
         };
     }
 }
+function resolveReactiveBaselineHead(run, issue) {
+    if (run.runType === "review_fix" || run.runType === "branch_upkeep") {
+        return run.sourceHeadSha;
+    }
+    if (run.runType === "ci_repair" || run.runType === "queue_repair") {
+        return issue.lastGitHubFailureHeadSha;
+    }
+    return undefined;
+}
+function isReactiveScopeRiskPath(filePath) {
+    return REACTIVE_SCOPE_RISK_EXACT_PATHS.has(filePath)
+        || REACTIVE_SCOPE_RISK_PREFIXES.some((prefix) => filePath.startsWith(prefix));
+}
 function hasStructuredReviewContext(context) {
     if (!context)
         return false;

package/dist/run-completion-policy.js

@@ -27,6 +27,9 @@ export class RunCompletionPolicy {
     async verifyReviewFixAdvancedHead(run, issue) {
         return await this.reactive.verifyReviewFixAdvancedHead(run, issue);
     }
+    async verifyReactiveRunStayedInScope(run, issue) {
+        return await this.reactive.verifyReactiveRunStayedInScope(run, issue);
+    }
     async refreshIssueAfterReactivePublish(run, issue) {
         return await this.reactive.refreshIssueAfterReactivePublish(run, issue);
     }

package/dist/run-finalizer.js

@@ -231,6 +231,19 @@ export class RunFinalizer {
             });
             return;
         }
+        const reactiveScopeError = await this.completionPolicy.verifyReactiveRunStayedInScope(run, freshIssue);
+        if (reactiveScopeError) {
+            this.failRunAndClear(run, reactiveScopeError, "escalated");
+            this.syncFailureOutcome({
+                run,
+                fallbackIssue: freshIssue,
+                message: reactiveScopeError,
+                level: "error",
+                status: "reactive_scope_drift_blocked",
+                summary: reactiveScopeError,
+            });
+            return;
+        }
         const publishedOutcomeError = await this.completionPolicy.verifyPublishedRunOutcome(run, freshIssue);
         if (publishedOutcomeError) {
             await handleNoPrCompletionCheck({

package/package.json

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