patchrelay 0.15.0 → 0.17.0

package/dist/merge-queue.js

@@ -1,4 +1,6 @@
+import { buildMergePrepActivity, buildMergePrepEscalationActivity } from "./linear-session-reporting.js";
 import { execCommand } from "./utils.js";
+const DEFAULT_MERGE_PREP_BUDGET = 3;
 /**
  * Merge queue steward — keeps PatchRelay-managed PR branches up to date
  * with the base branch and enables auto-merge so GitHub merges when CI passes.
@@ -14,12 +16,14 @@ export class MergeQueue {
     enqueueIssue;
     logger;
     feed;
-    constructor(config, db, enqueueIssue, logger, feed) {
+    onLinearActivity;
+    constructor(config, db, enqueueIssue, logger, feed, onLinearActivity) {
         this.config = config;
         this.db = db;
         this.enqueueIssue = enqueueIssue;
         this.logger = logger;
         this.feed = feed;
+        this.onLinearActivity = onLinearActivity;
     }
     /**
      * Prepare the front-of-queue issue for merge:
@@ -43,11 +47,37 @@ export class MergeQueue {
             this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false });
             return;
         }
+        // Retry budget — escalate after repeated infrastructure failures
+        const attempts = issue.mergePrepAttempts + 1;
+        this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, mergePrepAttempts: attempts });
+        if (attempts > DEFAULT_MERGE_PREP_BUDGET) {
+            this.logger.warn({ issueKey: issue.issueKey, attempts }, "Merge prep budget exhausted, escalating");
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                factoryState: "escalated",
+                pendingMergePrep: false,
+            });
+            this.feed?.publish({
+                level: "error",
+                kind: "workflow",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                stage: "awaiting_queue",
+                status: "escalated",
+                summary: `Merge prep failed ${attempts - 1} times — escalating for human help`,
+            });
+            this.onLinearActivity?.(issue, buildMergePrepEscalationActivity(attempts - 1));
+            return;
+        }
         const repoFullName = project.github?.repoFullName;
         const baseBranch = project.github?.baseBranch ?? "main";
         const gitBin = this.config.runner.gitBin;
         // Enable auto-merge (idempotent)
         const autoMergeOk = repoFullName ? await this.enableAutoMerge(issue, repoFullName) : false;
+        if (autoMergeOk) {
+            this.onLinearActivity?.(issue, buildMergePrepActivity("auto_merge"), { ephemeral: true });
+        }
         // Fetch latest base branch
         const fetchResult = await execCommand(gitBin, ["-C", issue.worktreePath, "fetch", "origin", baseBranch], {
             timeoutMs: 60_000,
@@ -55,6 +85,7 @@ export class MergeQueue {
         if (fetchResult.exitCode !== 0) {
             // Transient failure — leave pendingMergePrep set so the next event retries.
             this.logger.warn({ issueKey: issue.issueKey, stderr: fetchResult.stderr?.slice(0, 300) }, "Merge prep: fetch failed, will retry on next event");
+            this.onLinearActivity?.(issue, buildMergePrepActivity("fetch_retry"), { ephemeral: true });
             return;
         }
         // Merge base branch into the PR branch
@@ -72,6 +103,7 @@ export class MergeQueue {
                 pendingRunType: "queue_repair",
                 pendingRunContextJson: JSON.stringify({ failureReason: "merge_conflict" }),
                 pendingMergePrep: false,
+                mergePrepAttempts: 0,
             });
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
             this.feed?.publish({
@@ -83,12 +115,13 @@ export class MergeQueue {
                 status: "conflict",
                 summary: `Merge conflict with ${baseBranch} — queue repair enqueued`,
             });
+            this.onLinearActivity?.(issue, buildMergePrepActivity("conflict"));
             return;
         }
         // Check if merge was a no-op (already up to date)
         if (mergeResult.stdout?.includes("Already up to date")) {
             this.logger.debug({ issueKey: issue.issueKey }, "Merge prep: branch already up to date");
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false });
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false, mergePrepAttempts: 0 });
             if (!autoMergeOk) {
                 this.feed?.publish({
                     level: "warn",
@@ -99,6 +132,7 @@ export class MergeQueue {
                     status: "blocked",
                     summary: "Branch up to date but auto-merge not enabled — check gh auth and repo settings",
                 });
+                this.onLinearActivity?.(issue, buildMergePrepActivity("blocked"));
             }
             return;
         }
@@ -109,10 +143,11 @@ export class MergeQueue {
         if (pushResult.exitCode !== 0) {
             // Push failed — leave pendingMergePrep set so the next event retries.
             this.logger.warn({ issueKey: issue.issueKey, stderr: pushResult.stderr?.slice(0, 300) }, "Merge prep: push failed, will retry on next event");
+            this.onLinearActivity?.(issue, buildMergePrepActivity("push_retry"), { ephemeral: true });
             return;
         }
         this.logger.info({ issueKey: issue.issueKey, baseBranch }, "Merge prep: branch updated and pushed");
-        this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false });
+        this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingMergePrep: false, mergePrepAttempts: 0 });
         this.feed?.publish({
             level: "info",
             kind: "workflow",
@@ -122,6 +157,7 @@ export class MergeQueue {
             status: "prepared",
             summary: `Branch updated to latest ${baseBranch} — CI will run`,
         });
+        this.onLinearActivity?.(issue, buildMergePrepActivity("branch_update", baseBranch), { ephemeral: true });
     }
     /**
      * Seed the merge queue on startup: for each project, ensure the front-of-queue

package/dist/run-orchestrator.js

@@ -72,6 +72,7 @@ function buildRunPrompt(issue, runType, repoPath, context) {
     }
     return lines.join("\n");
 }
+const PROGRESS_THROTTLE_MS = 10_000;
 export class RunOrchestrator {
     config;
     db;
@@ -81,6 +82,7 @@ export class RunOrchestrator {
     logger;
     feed;
     worktreeManager;
+    progressThrottle = new Map();
     botIdentity;
     constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
         this.config = config;
@@ -253,6 +255,8 @@ export class RunOrchestrator {
                 eventJson: JSON.stringify(notification.params),
             });
         }
+        // Emit ephemeral progress activity to Linear for notable in-flight events
+        this.maybeEmitProgressActivity(notification, run);
         if (notification.method !== "turn/completed")
             return;
         const thread = await this.readThreadWithRetry(threadId);
@@ -286,6 +290,7 @@ export class RunOrchestrator {
             const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
             void this.emitLinearActivity(failedIssue, buildRunFailureActivity(run.runType));
             void this.syncLinearSession(failedIssue, { activeRunType: run.runType });
+            this.progressThrottle.delete(run.id);
             return;
         }
         // Complete the run
@@ -304,7 +309,7 @@ export class RunOrchestrator {
                 postRunState = "done";
             }
             else {
-                postRunState = "pr_open";
+                postRunState = "awaiting_review";
             }
         }
         this.db.transaction(() => {
@@ -347,6 +352,45 @@ export class RunOrchestrator {
             ...(updatedIssue.prNumber !== undefined ? { prNumber: updatedIssue.prNumber } : {}),
         }));
         void this.syncLinearSession(updatedIssue);
+        this.progressThrottle.delete(run.id);
+    }
+    // ─── In-flight progress ──────────────────────────────────────────
+    maybeEmitProgressActivity(notification, run) {
+        const activity = this.resolveProgressActivity(notification);
+        if (!activity)
+            return;
+        const now = Date.now();
+        const lastEmit = this.progressThrottle.get(run.id) ?? 0;
+        if (now - lastEmit < PROGRESS_THROTTLE_MS)
+            return;
+        this.progressThrottle.set(run.id, now);
+        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+        if (issue) {
+            void this.emitLinearActivity(issue, activity, { ephemeral: true });
+        }
+    }
+    resolveProgressActivity(notification) {
+        if (notification.method === "item/started") {
+            const item = notification.params.item;
+            if (!item)
+                return undefined;
+            const type = typeof item.type === "string" ? item.type : undefined;
+            if (type === "commandExecution") {
+                const cmd = item.command;
+                const cmdStr = Array.isArray(cmd) ? cmd.join(" ") : typeof cmd === "string" ? cmd : undefined;
+                return { type: "action", action: "Running", parameter: cmdStr?.slice(0, 120) ?? "command" };
+            }
+            if (type === "mcpToolCall") {
+                const server = typeof item.server === "string" ? item.server : "";
+                const tool = typeof item.tool === "string" ? item.tool : "";
+                return { type: "action", action: "Using", parameter: `${server}/${tool}` };
+            }
+            if (type === "dynamicToolCall") {
+                const tool = typeof item.tool === "string" ? item.tool : "tool";
+                return { type: "action", action: "Using", parameter: tool };
+            }
+        }
+        return undefined;
     }
     // ─── Active status for query ──────────────────────────────────────
     async getActiveRunStatus(issueKey) {

package/dist/service.js

@@ -35,7 +35,27 @@ export class PatchRelayService {
             throw new Error("Service runtime enqueueIssue is not initialized");
         };
         this.orchestrator = new RunOrchestrator(config, db, codex, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
-        this.mergeQueue = new MergeQueue(config, db, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
+        this.mergeQueue = new MergeQueue(config, db, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed, (issue, content, options) => {
+            if (!issue.agentSessionId)
+                return;
+            void (async () => {
+                try {
+                    const linear = await this.linearProvider.forProject(issue.projectId);
+                    if (!linear)
+                        return;
+                    const allowEphemeral = content.type === "thought" || content.type === "action";
+                    await linear.createAgentActivity({
+                        agentSessionId: issue.agentSessionId,
+                        content,
+                        ...(options?.ephemeral && allowEphemeral ? { ephemeral: true } : {}),
+                    });
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    logger.warn({ issueKey: issue.issueKey, type: content.type, error: msg }, "Failed to emit merge-prep Linear activity");
+                }
+            })();
+        });
         this.webhookHandler = new WebhookHandler(config, db, this.linearProvider, codex, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
         this.githubWebhookHandler = new GitHubWebhookHandler(config, db, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), this.mergeQueue, logger, this.feed);
         const runtime = new ServiceRuntime(codex, logger, this.orchestrator, { listIssuesReadyForExecution: () => db.listIssuesReadyForExecution() }, this.webhookHandler, {
@@ -198,6 +218,22 @@ export class PatchRelayService {
         this.codex.on("notification", handler);
         return () => { this.codex.off("notification", handler); };
     }
+    retryIssue(issueKey) {
+        const issue = this.db.getIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        if (issue.activeRunId)
+            return { error: "Issue already has an active run" };
+        const runType = "implementation";
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            pendingRunType: runType,
+            factoryState: "delegated",
+        });
+        this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
+        return { issueKey, runType };
+    }
     listOperatorFeed(options) {
         return this.feed.list(options);
     }
@@ -253,6 +289,9 @@ export class PatchRelayService {
     async getIssueReport(issueKey) {
         return await this.queryService.getIssueReport(issueKey);
     }
+    async getIssueTimeline(issueKey) {
+        return await this.queryService.getIssueTimeline(issueKey);
+    }
     async getRunEvents(issueKey, runId) {
         return await this.queryService.getRunEvents(issueKey, runId);
     }

package/dist/webhook-handler.js

@@ -1,6 +1,6 @@
 import { buildAgentSessionPlanForIssue, } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
-import { buildAlreadyRunningThought, buildDelegationThought, buildPromptDeliveredThought, } from "./linear-session-reporting.js";
+import { buildAlreadyRunningThought, buildDelegationThought, buildPromptDeliveredThought, buildStopConfirmationActivity, } from "./linear-session-reporting.js";
 import { resolveProject, triggerEventAllowed, trustedActorAllowed } from "./project-resolution.js";
 import { normalizeWebhook } from "./webhooks.js";
 import { InstallationWebhookHandler } from "./webhook-installation-handler.js";
@@ -210,6 +210,11 @@ export class WebhookHandler {
             });
             return;
         }
+        // Stop signal — halt active work and confirm disengagement
+        if (normalized.triggerEvent === "agentSignal" && normalized.agentSession.signal === "stop") {
+            await this.handleStopSignal(normalized, project, trackedIssue, existingIssue, activeRun, linear);
+            return;
+        }
         if (normalized.triggerEvent !== "agentPrompted")
             return;
         if (!triggerEventAllowed(project, normalized.triggerEvent))
@@ -251,6 +256,43 @@ export class WebhookHandler {
             await this.publishAgentActivity(linear, normalized.agentSession.id, buildDelegationThought(desiredStage, "prompt"), { ephemeral: true });
         }
     }
+    // ─── Stop signal handling ────────────────────────────────────────
+    async handleStopSignal(normalized, project, trackedIssue, existingIssue, activeRun, linear) {
+        const issueId = normalized.issue.id;
+        const sessionId = normalized.agentSession.id;
+        // Best-effort halt: steer the active Codex turn with a stop instruction
+        if (activeRun?.threadId && activeRun.turnId) {
+            try {
+                await this.codex.steerTurn({
+                    threadId: activeRun.threadId,
+                    turnId: activeRun.turnId,
+                    input: "STOP: The user has requested you stop working immediately. Do not make further changes. Wrap up and exit.",
+                });
+            }
+            catch (error) {
+                this.logger.warn({ issueKey: trackedIssue?.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to steer Codex turn for stop signal");
+            }
+            this.db.finishRun(activeRun.id, { status: "released", threadId: activeRun.threadId, turnId: activeRun.turnId });
+        }
+        this.db.upsertIssue({
+            projectId: project.id,
+            linearIssueId: issueId,
+            activeRunId: null,
+            factoryState: "awaiting_input",
+            agentSessionId: sessionId,
+        });
+        this.feed?.publish({
+            level: "info",
+            kind: "agent",
+            projectId: project.id,
+            issueKey: trackedIssue?.issueKey,
+            status: "stopped",
+            summary: "Stop signal received — work halted",
+        });
+        const updatedIssue = this.db.getIssue(project.id, issueId);
+        await this.publishAgentActivity(linear, sessionId, buildStopConfirmationActivity());
+        await this.syncAgentSession(linear, sessionId, updatedIssue ?? trackedIssue);
+    }
     // ─── Comment handling (inlined) ───────────────────────────────────
     async handleComment(normalized, project, trackedIssue) {
         if ((normalized.triggerEvent !== "commentCreated" && normalized.triggerEvent !== "commentUpdated") ||

package/dist/webhooks.js

@@ -46,6 +46,18 @@ function deriveTriggerEvent(payload) {
         ["resource", "agentSession"],
     ])) || Boolean(getString(data, "agentSessionId"));
     if (payload.type === "AgentSessionEvent" || payload.type === "AgentSession" || hasAgentSession) {
+        // Detect signal-bearing payloads (e.g. stop signal from Linear)
+        const agentActivityForSignal = getFirstNestedRecord(data, [
+            ["agentActivity"],
+            ["agentSession", "agentActivity"],
+            ["session", "agentActivity"],
+            ["agentSessionEvent", "agentActivity"],
+            ["payload", "agentActivity"],
+            ["resource", "agentActivity"],
+        ]);
+        if (agentActivityForSignal && getString(agentActivityForSignal, "signal")) {
+            return "agentSignal";
+        }
         if (payload.action === "created" || payload.action === "create") {
             return "agentSessionCreated";
         }
@@ -310,11 +322,15 @@ function extractAgentSessionMetadata(payload) {
         getString(commentRecord ?? {}, "body") ??
         getString(data, "body");
     const issueCommentId = getString(commentRecord ?? {}, "id") ?? getString(data, "issueCommentId");
+    const signal = getString(agentActivity ?? {}, "signal");
+    const signalMetadata = asRecord((agentActivity ?? {}).signalMetadata);
     return {
         id,
         ...(promptContext ? { promptContext } : {}),
         ...(promptBody ? { promptBody } : {}),
         ...(issueCommentId ? { issueCommentId } : {}),
+        ...(signal ? { signal } : {}),
+        ...(signalMetadata ? { signalMetadata } : {}),
     };
 }
 function extractInstallationMetadata(payload) {

package/package.json

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

package/dist/cli/watch/ThreadView.js

@@ -1,26 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-import { TurnSection } from "./TurnSection.js";
-function planStepSymbol(status) {
-    if (status === "completed")
-        return "\u2713";
-    if (status === "inProgress")
-        return "\u25b8";
-    return " ";
-}
-function planStepColor(status) {
-    if (status === "completed")
-        return "green";
-    if (status === "inProgress")
-        return "yellow";
-    return "white";
-}
-export function ThreadView({ thread, follow }) {
-    const visibleTurns = follow && thread.turns.length > 1
-        ? thread.turns.slice(-1)
-        : thread.turns;
-    const turnOffset = follow && thread.turns.length > 1
-        ? thread.turns.length - 1
-        : 0;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsxs(Text, { dimColor: true, children: ["Thread: ", thread.threadId.slice(0, 16)] }), _jsxs(Text, { dimColor: true, children: ["Status: ", thread.status] }), _jsxs(Text, { dimColor: true, children: ["Turns: ", thread.turns.length] })] }), thread.plan && thread.plan.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Plan:" }), thread.plan.map((entry, i) => (_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: planStepColor(entry.status), children: ["[", planStepSymbol(entry.status), "]"] }), _jsx(Text, { children: entry.step })] }, `plan-${i}`)))] })), _jsx(Box, { flexDirection: "column", marginTop: 1, children: visibleTurns.map((turn, i) => (_jsx(TurnSection, { turn: turn, index: i + turnOffset, follow: follow }, turn.id))) })] }));
-}

package/dist/cli/watch/TurnSection.js

@@ -1,20 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-import { ItemLine } from "./ItemLine.js";
-function turnStatusColor(status) {
-    if (status === "completed")
-        return "green";
-    if (status === "failed" || status === "interrupted")
-        return "red";
-    if (status === "inProgress")
-        return "yellow";
-    return "white";
-}
-const FOLLOW_TAIL_SIZE = 8;
-export function TurnSection({ turn, index, follow }) {
-    const items = follow && turn.items.length > FOLLOW_TAIL_SIZE
-        ? turn.items.slice(-FOLLOW_TAIL_SIZE)
-        : turn.items;
-    const skipped = turn.items.length - items.length;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsxs(Text, { bold: true, children: ["Turn #", index + 1] }), _jsx(Text, { color: turnStatusColor(turn.status), children: turn.status }), _jsxs(Text, { dimColor: true, children: ["(", turn.items.length, " items)"] })] }), skipped > 0 && _jsxs(Text, { dimColor: true, children: ["  ... ", skipped, " earlier items"] }), items.map((item, i) => (_jsx(ItemLine, { item: item, isLast: i === items.length - 1 }, item.id)))] }));
-}