patchrelay 0.16.0 → 0.17.1

package/dist/run-orchestrator.js

@@ -9,8 +9,9 @@ import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
 import { WorktreeManager } from "./worktree-manager.js";
 import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
 import { execCommand } from "./utils.js";
-const DEFAULT_CI_REPAIR_BUDGET = 2;
-const DEFAULT_QUEUE_REPAIR_BUDGET = 2;
+const DEFAULT_CI_REPAIR_BUDGET = 3;
+const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
+const DEFAULT_REVIEW_FIX_BUDGET = 3;
 function slugify(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 }
@@ -72,6 +73,7 @@ function buildRunPrompt(issue, runType, repoPath, context) {
     }
     return lines.join("\n");
 }
+const PROGRESS_THROTTLE_MS = 10_000;
 export class RunOrchestrator {
     config;
     db;
@@ -81,6 +83,7 @@ export class RunOrchestrator {
     logger;
     feed;
     worktreeManager;
+    progressThrottle = new Map();
     botIdentity;
     constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
         this.config = config;
@@ -112,6 +115,10 @@ export class RunOrchestrator {
             this.escalate(issue, runType, `Queue repair budget exhausted (${DEFAULT_QUEUE_REPAIR_BUDGET} attempts)`);
             return;
         }
+        if (runType === "review_fix" && issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
+            this.escalate(issue, runType, `Review fix budget exhausted (${DEFAULT_REVIEW_FIX_BUDGET} attempts)`);
+            return;
+        }
         // Increment repair counters
         if (runType === "ci_repair") {
             this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, ciRepairAttempts: issue.ciRepairAttempts + 1 });
@@ -119,6 +126,9 @@ export class RunOrchestrator {
         if (runType === "queue_repair") {
             this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, queueRepairAttempts: issue.queueRepairAttempts + 1 });
         }
+        if (runType === "review_fix") {
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, reviewFixAttempts: issue.reviewFixAttempts + 1 });
+        }
         // Build prompt
         const prompt = buildRunPrompt(issue, runType, project.repoPath, context);
         // Resolve workspace
@@ -253,6 +263,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,27 +298,15 @@ 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
         const trackedIssue = this.db.issueToTrackedIssue(issue);
         const report = buildStageReport(run, trackedIssue, thread, countEventMethods(this.db.listThreadEvents(run.id)));
-        // Determine post-run state. When a re-run finds the PR already exists
-        // and makes no changes, no pr_opened webhook arrives — the state would
-        // stay in the active-run state forever. Advance based on PR metadata.
+        // Determine post-run state based on current PR metadata.
         const freshIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
-        let postRunState;
-        if (ACTIVE_RUN_STATES.has(freshIssue.factoryState) && freshIssue.prNumber) {
-            if (freshIssue.prReviewState === "approved") {
-                postRunState = "awaiting_queue";
-            }
-            else if (freshIssue.prState === "merged") {
-                postRunState = "done";
-            }
-            else {
-                postRunState = "awaiting_review";
-            }
-        }
+        const postRunState = resolvePostRunState(freshIssue);
         this.db.transaction(() => {
             this.db.finishRun(run.id, {
                 status: "completed",
@@ -347,6 +347,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) {
@@ -500,6 +539,8 @@ export class RunOrchestrator {
         if (latestTurn?.status === "completed") {
             const trackedIssue = this.db.issueToTrackedIssue(issue);
             const report = buildStageReport(run, trackedIssue, thread, countEventMethods(this.db.listThreadEvents(run.id)));
+            const freshIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            const postRunState = resolvePostRunState(freshIssue);
             this.db.transaction(() => {
                 this.db.finishRun(run.id, {
                     status: "completed",
@@ -512,8 +553,13 @@ export class RunOrchestrator {
                     projectId: run.projectId,
                     linearIssueId: run.linearIssueId,
                     activeRunId: null,
+                    ...(postRunState ? { factoryState: postRunState } : {}),
+                    ...(postRunState === "awaiting_queue" ? { pendingMergePrep: true } : {}),
                 });
             });
+            if (postRunState === "awaiting_queue") {
+                this.enqueueIssue(run.projectId, run.linearIssueId);
+            }
         }
     }
     // ─── Internal helpers ─────────────────────────────────────────────
@@ -616,3 +662,17 @@ export class RunOrchestrator {
         throw new Error(`Failed to read thread ${threadId}`);
     }
 }
+/**
+ * Determine post-run factory state from current PR metadata.
+ * Used by both the normal completion path and reconciliation.
+ */
+function resolvePostRunState(issue) {
+    if (ACTIVE_RUN_STATES.has(issue.factoryState) && issue.prNumber) {
+        if (issue.prReviewState === "approved")
+            return "awaiting_queue";
+        if (issue.prState === "merged")
+            return "done";
+        return "pr_open";
+    }
+    return undefined;
+}

package/dist/service.js

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

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

package/dist/cli/watch/FeedTimeline.js

@@ -1,23 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-const KIND_COLORS = {
-    stage: "cyan",
-    turn: "yellow",
-    github: "green",
-    webhook: "blue",
-    workflow: "magenta",
-    hook: "white",
-};
-function kindColor(kind) {
-    return KIND_COLORS[kind] ?? "white";
-}
-function formatTime(iso) {
-    return new Date(iso).toLocaleTimeString("en-GB", { hour12: false });
-}
-export function FeedTimeline({ entries, maxEntries }) {
-    const visible = maxEntries ? entries.slice(-maxEntries) : entries;
-    if (visible.length === 0) {
-        return _jsx(Text, { dimColor: true, children: "No events yet." });
-    }
-    return (_jsx(Box, { flexDirection: "column", children: visible.map((entry, i) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { color: kindColor(entry.kind), children: (entry.status ?? entry.kind).padEnd(15) }), _jsx(Text, { children: entry.summary })] }, `feed-${i}`))) }));
-}

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)))] }));
-}