patchrelay 0.73.3 → 0.73.4

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.73.4",
+  "commit": "94b5acdba50b",
+  "builtAt": "2026-05-27T20:52:10.985Z"
 }

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/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/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/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/package.json

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