patchrelay 0.7.2 → 0.7.3

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.7.2",
-  "commit": "ae8c74a3c09a",
-  "builtAt": "2026-03-14T07:49:19.447Z"
+  "version": "0.7.3",
+  "commit": "ab85617bb14d",
+  "builtAt": "2026-03-14T13:31:07.892Z"
 }

package/dist/config.js

@@ -101,7 +101,7 @@ const configSchema = z.object({
 });
 function defaultTriggerEvents(actor) {
     if (actor === "app") {
-        return ["agentSessionCreated", "agentPrompted", "statusChanged"];
+        return ["issueCreated", "agentSessionCreated", "agentPrompted", "statusChanged"];
     }
     return ["statusChanged"];
 }

package/dist/reconciliation-snapshot-builder.js

@@ -28,10 +28,11 @@ export async function buildReconciliationSnapshot(params) {
             .catch(() => ({ status: "unknown" }))
         : ({ status: "unknown" });
     const liveCodex = runLease.threadId
-        ? await params.codex
-            .readThread(runLease.threadId, true)
-            .then((thread) => ({ status: "found", thread }))
-            .catch((error) => mapCodexReadFailure(error))
+        ? await hydrateLiveCodexState({
+            codex: params.codex,
+            threadId: runLease.threadId,
+            ...(workspaceOwnership?.worktreePath ? { cwd: workspaceOwnership.worktreePath } : {}),
+        })
         : ({ status: "unknown" });
     const obligations = params.stores.obligations
         .listPendingObligations({ runLeaseId: runLease.id, includeInProgress: true })
@@ -83,6 +84,39 @@ export async function buildReconciliationSnapshot(params) {
         },
     };
 }
+async function hydrateLiveCodexState(params) {
+    try {
+        const thread = await params.codex.readThread(params.threadId, true);
+        if (latestThreadTurn(thread)?.status === "interrupted" && params.cwd) {
+            const resumedThread = await tryResumeThread(params.codex, params.threadId, params.cwd);
+            if (resumedThread) {
+                return { status: "found", thread: resumedThread };
+            }
+        }
+        return { status: "found", thread };
+    }
+    catch (error) {
+        const mapped = mapCodexReadFailure(error);
+        if (mapped.status === "missing" && params.cwd) {
+            const resumedThread = await tryResumeThread(params.codex, params.threadId, params.cwd);
+            if (resumedThread) {
+                return { status: "found", thread: resumedThread };
+            }
+        }
+        return mapped;
+    }
+}
+async function tryResumeThread(codex, threadId, cwd) {
+    try {
+        return await codex.resumeThread(threadId, cwd);
+    }
+    catch {
+        return undefined;
+    }
+}
+function latestThreadTurn(thread) {
+    return thread.turns.at(-1);
+}
 function mapCodexReadFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     const normalized = message.trim().toLowerCase();

package/dist/service-stage-finalizer.js

@@ -11,22 +11,23 @@ export class ServiceStageFinalizer {
     codex;
     linearProvider;
     enqueueIssue;
+    logger;
     feed;
     inputDispatcher;
     lifecyclePublisher;
     actionApplier;
     runAtomically;
-    constructor(config, stores, codex, linearProvider, enqueueIssue, logger, feed, runAtomically = (fn) => fn()) {
+    constructor(config, stores, codex, linearProvider, enqueueIssue, logger = consoleLogger(), feed, runAtomically = (fn) => fn()) {
         this.config = config;
         this.stores = stores;
         this.codex = codex;
         this.linearProvider = linearProvider;
         this.enqueueIssue = enqueueIssue;
+        this.logger = logger;
         this.feed = feed;
         this.runAtomically = runAtomically;
-        const lifecycleLogger = logger ?? consoleLogger();
-        this.inputDispatcher = new StageTurnInputDispatcher(stores, codex, lifecycleLogger);
-        this.lifecyclePublisher = new StageLifecyclePublisher(config, stores, linearProvider, lifecycleLogger, feed);
+        this.inputDispatcher = new StageTurnInputDispatcher(stores, codex, this.logger);
+        this.lifecyclePublisher = new StageLifecyclePublisher(config, stores, linearProvider, this.logger, feed);
         this.actionApplier = new ReconciliationActionApplier({
             enqueueIssue,
             deliverPendingObligations: (projectId, linearIssueId, threadId, turnId) => this.deliverPendingObligations(projectId, linearIssueId, threadId, turnId),
@@ -296,6 +297,9 @@ export class ServiceStageFinalizer {
         if (!snapshot) {
             return;
         }
+        if (await this.restartInterruptedRun(snapshot)) {
+            return;
+        }
         const decision = reconcileIssue(snapshot.input);
         if (decision.outcome === "hydrate_live_state") {
             throw new Error(`Startup reconciliation requires live state hydration for ${snapshot.runLease.projectId}:${snapshot.runLease.linearIssueId}: ${decision.reasons.join("; ")}`);
@@ -305,6 +309,63 @@ export class ServiceStageFinalizer {
             decision,
         });
     }
+    async restartInterruptedRun(snapshot) {
+        const liveCodex = snapshot.input.live?.codex;
+        const latestTurn = liveCodex?.status === "found" ? liveCodex.thread?.turns.at(-1) : undefined;
+        if (latestTurn?.status !== "interrupted") {
+            return false;
+        }
+        if (snapshot.runLease.turnId && latestTurn.id !== snapshot.runLease.turnId) {
+            return true;
+        }
+        if (!snapshot.runLease.threadId || !snapshot.workspaceOwnership?.worktreePath) {
+            return false;
+        }
+        const stageRun = this.findStageRunForIssue(snapshot.runLease.projectId, snapshot.runLease.linearIssueId, snapshot.runLease.threadId);
+        if (!stageRun) {
+            return false;
+        }
+        const issue = this.stores.issueWorkflows.getTrackedIssue(stageRun.projectId, stageRun.linearIssueId);
+        const turn = await this.codex.startTurn({
+            threadId: snapshot.runLease.threadId,
+            cwd: snapshot.workspaceOwnership.worktreePath,
+            input: buildRestartRecoveryPrompt(stageRun.stage),
+        });
+        this.stores.workflowCoordinator.updateStageRunThread({
+            stageRunId: stageRun.id,
+            threadId: snapshot.runLease.threadId,
+            turnId: turn.turnId,
+        });
+        this.inputDispatcher.routePendingInputs(stageRun, snapshot.runLease.threadId, turn.turnId);
+        await this.inputDispatcher.flush({
+            id: stageRun.id,
+            projectId: stageRun.projectId,
+            linearIssueId: stageRun.linearIssueId,
+            threadId: snapshot.runLease.threadId,
+            turnId: turn.turnId,
+        }, {
+            logFailures: true,
+            failureMessage: "Failed to deliver queued Linear comment during interrupted-turn recovery",
+            ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
+        });
+        this.logger.info({
+            issueKey: issue?.issueKey,
+            stage: stageRun.stage,
+            threadId: snapshot.runLease.threadId,
+            turnId: turn.turnId,
+        }, "Restarted interrupted Codex stage run during startup reconciliation");
+        this.feed?.publish({
+            level: "info",
+            kind: "stage",
+            issueKey: issue?.issueKey,
+            projectId: stageRun.projectId,
+            stage: stageRun.stage,
+            status: "running",
+            summary: `Recovered ${stageRun.stage} workflow after restart`,
+            detail: `Turn ${turn.turnId} resumed on the existing thread.`,
+        });
+        return true;
+    }
     completeReconciledRun(projectId, linearIssueId, thread, params) {
         const stageRun = this.findStageRunForIssue(projectId, linearIssueId, params.threadId);
         const issue = this.stores.issueWorkflows.getTrackedIssue(projectId, linearIssueId);
@@ -380,3 +441,12 @@ function consoleLogger() {
         level: "silent",
     };
 }
+function buildRestartRecoveryPrompt(stage) {
+    return [
+        `PatchRelay restarted while the ${stage} workflow was mid-turn.`,
+        "Resume the existing work from the current worktree state on this same thread.",
+        "Inspect any uncommitted changes you already made before continuing.",
+        "Continue from the interrupted point instead of restarting the task from scratch.",
+        "When the work is actually complete, finish the normal workflow handoff for this stage.",
+    ].join("\n");
+}

package/package.json

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