patchrelay 0.49.3 → 0.50.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.49.3",
-  "commit": "39948af65ed2",
-  "builtAt": "2026-04-20T00:34:55.802Z"
+  "version": "0.50.1",
+  "commit": "27eb3a4a1840",
+  "builtAt": "2026-04-20T12:44:08.573Z"
 }

package/dist/cli/cluster-health.js

@@ -490,7 +490,13 @@ function deriveCiOwner(params) {
             return "paused";
         if (params.factoryState === "changes_requested")
             return "patchrelay";
-        if (params.reviewQuillAttempt)
+        if (params.reviewQuillAttempt?.backlog
+            && params.currentHeadSha
+            && params.reviewQuillAttempt.headSha
+            && params.currentHeadSha !== params.reviewQuillAttempt.headSha) {
+            return "review-quill";
+        }
+        if (params.reviewQuillAttempt && !params.reviewQuillAttempt.backlog)
             return "review-quill";
         if (headAdvancedPastBlockingReview)
             return "reviewer";
@@ -524,7 +530,10 @@ function describeCiOwnership(params) {
             : "PatchRelay owns the next requested-changes move";
     }
     if (params.owner === "review-quill") {
-        return params.reviewQuillAttempt
+        if (params.reviewQuillAttempt?.backlog) {
+            return "review-quill is actively reconciling this repo; this PR is waiting in the current review backlog";
+        }
+        return params.reviewQuillAttempt?.id && params.reviewQuillAttempt.status
             ? `review-quill attempt #${params.reviewQuillAttempt.id} is ${params.reviewQuillAttempt.status} on the current head`
             : "review-quill owns the current review attempt";
     }
@@ -576,7 +585,14 @@ function describeCiOwnership(params) {
     return "No visible next owner for this PR state";
 }
 function isResolvedDependency(dep) {
-    return dep.blockerCurrentLinearStateType === "completed" || dep.blockerCurrentLinearState?.trim().toLowerCase() === "done";
+    const stateType = dep.blockerCurrentLinearStateType?.trim().toLowerCase();
+    const state = dep.blockerCurrentLinearState?.trim().toLowerCase();
+    return stateType === "completed"
+        || stateType === "canceled"
+        || stateType === "cancelled"
+        || state === "done"
+        || state === "canceled"
+        || state === "cancelled";
 }
 function needsReviewAutomation(issue) {
     if (issue.factoryState === "awaiting_queue" || issue.factoryState === "done") {
@@ -586,6 +602,7 @@ function needsReviewAutomation(issue) {
 }
 async function collectReviewQuillAttemptOwners(snapshots, config, runCommand) {
     const owners = new Map();
+    const repoBacklog = await probeReviewQuillRepoBacklog(runCommand);
     for (const snapshot of snapshots) {
         const issueKey = snapshot.issue.issueKey;
         const prNumber = snapshot.issue.prNumber;
@@ -601,8 +618,12 @@ async function collectReviewQuillAttemptOwners(snapshots, config, runCommand) {
         const activeAttempt = probe.attempts.find((attempt) => (attempt.status === "queued" || attempt.status === "running")
             && !attempt.stale
             && attempt.headSha === probe.currentHeadSha);
-        if (!activeAttempt)
+        if (!activeAttempt) {
+            if (repoBacklog.has(repoFullName)) {
+                owners.set(issueKey, { backlog: true, headSha: probe.latestAttemptHeadSha });
+            }
             continue;
+        }
         owners.set(issueKey, {
             id: activeAttempt.id,
             status: activeAttempt.status,
@@ -611,6 +632,42 @@ async function collectReviewQuillAttemptOwners(snapshots, config, runCommand) {
     }
     return owners;
 }
+async function probeReviewQuillRepoBacklog(runCommand) {
+    let result;
+    try {
+        result = await runCommand("review-quill", ["status", "--json"]);
+    }
+    catch {
+        return new Set();
+    }
+    if (result.exitCode !== 0) {
+        return new Set();
+    }
+    const parsed = safeJsonParse(result.stdout);
+    if (!parsed || parsed.runtime?.reconcileInProgress !== true || !Array.isArray(parsed.repos)) {
+        return new Set();
+    }
+    const activeRepos = new Set();
+    for (const repo of parsed.repos) {
+        if (!repo || typeof repo !== "object")
+            continue;
+        const repoFullName = typeof repo.repoFullName === "string"
+            ? String(repo.repoFullName).trim()
+            : undefined;
+        const runningAttempts = typeof repo.runningAttempts === "number"
+            ? Number(repo.runningAttempts)
+            : 0;
+        const queuedAttempts = typeof repo.queuedAttempts === "number"
+            ? Number(repo.queuedAttempts)
+            : 0;
+        if (!repoFullName)
+            continue;
+        if (runningAttempts > 0 || queuedAttempts > 0) {
+            activeRepos.add(repoFullName);
+        }
+    }
+    return activeRepos;
+}
 async function collectActiveOverlapFindings(snapshots, runCommand) {
     const findings = [];
     const diffsByProject = new Map();
@@ -723,6 +780,7 @@ async function probeReviewQuillAttempts(runCommand, repoFullName, prNumber) {
     if (!prProbe.ok) {
         return { ok: false, error: prProbe.error };
     }
+    let latestAttemptHeadSha;
     const attempts = parsedAttempts.attempts.flatMap((entry) => {
         if (!entry || typeof entry !== "object")
             return [];
@@ -730,6 +788,9 @@ async function probeReviewQuillAttempts(runCommand, repoFullName, prNumber) {
         const headSha = entry.headSha;
         const status = entry.status;
         const stale = entry.stale;
+        if (!latestAttemptHeadSha && typeof headSha === "string" && headSha.trim().length > 0) {
+            latestAttemptHeadSha = headSha.trim();
+        }
         if (typeof id !== "number"
             || typeof headSha !== "string"
             || (status !== "queued" && status !== "running")) {
@@ -745,6 +806,7 @@ async function probeReviewQuillAttempts(runCommand, repoFullName, prNumber) {
     return {
         ok: true,
         currentHeadSha: prProbe.pr.headRefOid,
+        latestAttemptHeadSha,
         attempts,
     };
 }

package/dist/cli/watch/IssueRow.js

@@ -1,10 +1,15 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { issueTokenFor, prTokenFor } from "./issue-token.js";
-import { truncate } from "./format-utils.js";
+import { formatIssueAge, truncate } from "./format-utils.js";
 const KEY_WIDTH = 8;
 const GLYPH_WIDTH = 3;
 const PHRASE_WIDTH = 18;
+const AGE_WIDTH = 4;
+const WIDE_PR_PHRASE_THRESHOLD = 34;
+function shouldShowVerbosePrToken(titleWidth, compact) {
+    return !compact && (titleWidth ?? 60) >= WIDE_PR_PHRASE_THRESHOLD;
+}
 export function IssueRow({ issue, selected, titleWidth, compact = false, }) {
     const key = issue.issueKey ?? issue.projectId;
     const token = issueTokenFor(issue);
@@ -12,11 +17,18 @@ export function IssueRow({ issue, selected, titleWidth, compact = false, }) {
     const cursorChar = selected ? "\u25b8" : " ";
     const paddedKey = key.padEnd(KEY_WIDTH, " ");
     const paddedPhrase = token.phrase.padEnd(PHRASE_WIDTH, " ");
-    const availableTitleWidth = Math.max(0, (titleWidth ?? 60) - (pr ? 10 : 0));
+    const age = formatIssueAge(issue.updatedAt);
+    const verbosePr = pr && shouldShowVerbosePrToken(titleWidth, compact);
+    const prWidth = pr
+        ? verbosePr
+            ? `#${pr.prNumber} ${pr.glyph} ${pr.phrase}`.length
+            : `#${pr.prNumber} ${pr.glyph}`.length
+        : 0;
+    const availableTitleWidth = Math.max(0, (titleWidth ?? 60) - prWidth - (pr ? 2 : 0) - (AGE_WIDTH + 2));
     const title = !compact && selected && issue.title
         ? `  ${truncate(issue.title, Math.max(0, availableTitleWidth))}`
         : "";
-    return (_jsxs(Box, { children: [_jsx(Text, { color: selected ? "cyan" : "gray", children: cursorChar }), _jsx(Text, { bold: selected, color: token.color, children: ` ${paddedKey}` }), _jsx(Text, { color: token.color, children: ` ${token.glyph.padEnd(GLYPH_WIDTH - 1, " ")}` }), _jsx(Text, { children: ` ${paddedPhrase}` }), pr ? (_jsx(_Fragment, { children: _jsx(Text, { color: pr.color, children: `#${pr.prNumber} ${pr.glyph}` }) })) : null, title ? _jsx(Text, { dimColor: true, children: title }) : null] }));
+    return (_jsxs(Box, { children: [_jsx(Text, { color: selected ? "cyan" : "gray", children: cursorChar }), _jsx(Text, { bold: selected, color: token.color, children: ` ${paddedKey}` }), _jsx(Text, { color: token.color, children: ` ${token.glyph.padEnd(GLYPH_WIDTH - 1, " ")}` }), _jsx(Text, { children: ` ${paddedPhrase}` }), pr ? (_jsx(_Fragment, { children: _jsx(Text, { color: pr.color, children: verbosePr ? `#${pr.prNumber} ${pr.glyph} ${pr.phrase}` : `#${pr.prNumber} ${pr.glyph}` }) })) : null, _jsx(Text, { dimColor: true, children: `  ${age}` }), title ? _jsx(Text, { dimColor: true, children: title }) : null] }));
 }
 export function estimateIssueRowHeight(_issue, _selected, _cols, _titleWidth, _compact = false) {
     return 1;

package/dist/cli/watch/format-utils.js

@@ -19,6 +19,9 @@ export function relativeTime(iso) {
     const days = Math.floor(hours / 24);
     return `${days}d`;
 }
+export function formatIssueAge(updatedAt) {
+    return relativeTime(updatedAt).padStart(4, " ");
+}
 /** Format millisecond duration as "2m 30s" or "45s". */
 export function formatDuration(ms) {
     const seconds = Math.floor(ms / 1000);

package/dist/cli/watch/issue-token.js

@@ -1,4 +1,5 @@
 import { isUndelegatedPausedIssue } from "../../paused-issue-state.js";
+import { hasFailedPrChecks, hasPendingPrChecks, isApprovedReviewState, isAwaitingReviewState, isChangesRequestedReviewState, prChecksFact, } from "./pr-status.js";
 const GLYPH = {
     running: "\u25cf",
     queued: "\u25cb",
@@ -84,6 +85,7 @@ export function prTokenFor(issue) {
         glyph: GLYPH[kind],
         color: COLOR[kind],
         kind,
+        phrase: prPhraseFor(issue),
     };
 }
 function prKind(issue) {
@@ -101,3 +103,20 @@ function prKind(issue) {
         return "approved";
     return "running";
 }
+function prPhraseFor(issue) {
+    if (issue.prState === "merged")
+        return "merged";
+    if (issue.prState === "closed")
+        return "closed";
+    if (isChangesRequestedReviewState(issue.prReviewState))
+        return "changes req";
+    if (isApprovedReviewState(issue.prReviewState))
+        return "approved";
+    if (isAwaitingReviewState(issue.prReviewState))
+        return "awaiting review";
+    if (hasFailedPrChecks(issue))
+        return prChecksFact(issue)?.text ?? "checks failed";
+    if (hasPendingPrChecks(issue))
+        return prChecksFact(issue)?.text ?? "checks running";
+    return prChecksFact(issue)?.text ?? "open";
+}

package/dist/config.js

@@ -22,9 +22,9 @@ const repoSettingsSchema = z.object({
     branch_prefix: z.string().min(1).optional(),
 });
 const repairBudgetsSchema = z.object({
-    ci_repair: z.number().int().positive().default(3),
-    queue_repair: z.number().int().positive().default(3),
-    review_fix: z.number().int().positive().default(3),
+    ci_repair: z.number().int().positive().default(10),
+    queue_repair: z.number().int().positive().default(10),
+    review_fix: z.number().int().positive().default(10),
 });
 const projectSchema = z.object({
     id: z.string().min(1),
@@ -37,9 +37,9 @@ const projectSchema = z.object({
     trigger_events: z.array(z.string().min(1)).min(1).optional(),
     branch_prefix: z.string().min(1).optional(),
     repair_budgets: repairBudgetsSchema.default({
-        ci_repair: 3,
-        queue_repair: 3,
-        review_fix: 3,
+        ci_repair: 10,
+        queue_repair: 10,
+        review_fix: 10,
     }),
     /** Check names that are review gates (AI Review, quality analysis). Default: code class. */
     review_checks: z.array(z.string().min(1)).default([]),
@@ -63,9 +63,9 @@ const repositorySchema = z.object({
     trigger_events: z.array(z.string().min(1)).min(1).optional(),
     branch_prefix: z.string().min(1).optional(),
     repair_budgets: repairBudgetsSchema.default({
-        ci_repair: 3,
-        queue_repair: 3,
-        review_fix: 3,
+        ci_repair: 10,
+        queue_repair: 10,
+        review_fix: 10,
     }),
     github: z.object({
         webhook_secret: z.string().min(1).optional(),

package/dist/issue-class.js

@@ -1,35 +1,15 @@
-function normalizeText(value) {
-    return value?.trim().toLowerCase() ?? "";
-}
-function looksLikeUmbrellaText(issue) {
-    const haystack = `${normalizeText(issue.title)}\n${normalizeText(issue.description)}`;
-    if (!haystack.trim())
-        return false;
-    return [
-        "umbrella",
-        "tracker",
-        "tracking",
-        "rollout",
-        "migration",
-        "convergence",
-        "audit",
-        "follow-up issues",
-        "planning/specification issue only",
-    ].some((token) => haystack.includes(token));
-}
 export function classifyIssue(params) {
-    if (params.issue.issueClassSource === "explicit"
-        && (params.issue.issueClass === "implementation" || params.issue.issueClass === "orchestration")) {
-        return { issueClass: params.issue.issueClass, issueClassSource: "explicit" };
-    }
     if (params.issue.parentLinearIssueId) {
         return { issueClass: "implementation", issueClassSource: "hierarchy" };
     }
     if (params.childIssueCount > 0) {
+        if (params.issue.issueClassSource === "explicit" && params.issue.issueClass === "orchestration") {
+            return { issueClass: "orchestration", issueClassSource: "explicit" };
+        }
         return { issueClass: "orchestration", issueClassSource: "hierarchy" };
     }
-    if (looksLikeUmbrellaText(params.issue)) {
-        return { issueClass: "orchestration", issueClassSource: "heuristic" };
+    if (params.issue.issueClassSource === "explicit" && params.issue.issueClass === "implementation") {
+        return { issueClass: "implementation", issueClassSource: "explicit" };
     }
     return { issueClass: "implementation", issueClassSource: "heuristic" };
 }

package/dist/prompting/patchrelay.js

@@ -182,10 +182,15 @@ function buildOrchestrationScopeDiscipline(context) {
         "Adopt already-existing canonical child issues when they cover the intended split.",
         "Do not recreate child issues that already exist under this parent unless a genuinely missing required slice remains.",
         "Do not create an overlapping umbrella PR unless this parent clearly owns unique direct cleanup work that child issues do not already cover.",
+        "When you split required implementation work out of the parent, make it a child issue of this umbrella rather than making the parent block the child.",
+        "If sequencing matters, let the parent wait on the child; do not model the child as blocked by the parent umbrella it is supposed to satisfy.",
         "If child work is still in motion, babysit the plan, record useful observations, and return to waiting.",
         "If child work looks delivered, audit whether the original parent goal is actually satisfied.",
         "Create blocking follow-up work only when it is necessary to satisfy the original parent goal.",
         "Prefer non-blocking follow-up issues over keeping the umbrella open for optional polish or adjacent expansion.",
+        "New child issues should stay in Backlog and undelegated by default.",
+        "Only delegate or move a new child to Start when it is immediately actionable, unblocked, and you intend for PatchRelay to begin it right away.",
+        "If you create multiple new child issues, keep later-wave or dependency-bound children queued rather than waking them all at once.",
         "",
         "### Child Issue Summaries",
         "",
@@ -476,6 +481,7 @@ function buildOrchestrationWorkflowGuidance() {
         "",
         "Use the wake reason and current child issue summaries to decide what kind of orchestration work is needed now.",
         "Typical orchestration phases are: initial setup, waiting on child progress, reviewing delivered child work, final audit, creating a justified follow-up, or closing the umbrella.",
+        "When creating follow-up work, prefer one immediately runnable child at a time and keep the rest queued until their prerequisites are genuinely ready.",
         "Keep outputs concise and observable in Linear.",
     ].join("\n");
 }
@@ -488,6 +494,8 @@ function buildPublicationContract(runType, issueClass) {
             "By default, orchestration work should finish without opening an overlapping umbrella PR.",
             "Valid orchestration outcomes include: recording an observation, updating the rollout plan, creating follow-up issues, opening a small cleanup PR that the parent clearly owns, or closing the umbrella.",
             "If you create new blocking follow-up work, justify it against the original parent goal rather than optional polish.",
+            "Blocking follow-up children must block the parent goal they satisfy, not the other way around.",
+            "If you create new child issues, leave them in Backlog unless they are truly ready to start now.",
         ].join("\n");
     }
     if (runType === "implementation") {

package/dist/run-budgets.js

@@ -1,6 +1,6 @@
-export const DEFAULT_CI_REPAIR_BUDGET = 3;
-export const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
-export const DEFAULT_REVIEW_FIX_BUDGET = 3;
+export const DEFAULT_CI_REPAIR_BUDGET = 10;
+export const DEFAULT_QUEUE_REPAIR_BUDGET = 10;
+export const DEFAULT_REVIEW_FIX_BUDGET = 10;
 export function getCiRepairBudget(project) {
     return project?.repairBudgets?.ciRepair ?? DEFAULT_CI_REPAIR_BUDGET;
 }

package/dist/webhooks/desired-stage-recorder.js

@@ -304,13 +304,15 @@ export class DesiredStageRecorder {
                     ? "child_delivered"
                     : wasResolved && !isResolved
                         ? "child_regressed"
-                        : "child_changed";
-            wakeOrchestrationParentsForChildEvent({
-                db: this.db,
-                child: issue,
-                eventType,
-                changeKind,
-            });
+                        : undefined;
+            if (eventType) {
+                wakeOrchestrationParentsForChildEvent({
+                    db: this.db,
+                    child: issue,
+                    eventType,
+                    changeKind,
+                });
+            }
         }
         return {
             issue: this.db.issueToTrackedIssue(issue),

package/package.json

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