patchrelay 0.68.6 → 0.69.0

package/dist/linear-progress-reporter.js

@@ -2,10 +2,13 @@ import { deriveLinearProgressFact } from "./linear-progress-facts.js";
 export class LinearProgressReporter {
     db;
     emitActivity;
+    options;
+    static DEFAULT_HEARTBEAT_INTERVAL_MS = 15 * 60 * 1000;
     publicationsByRun = new Map();
-    constructor(db, emitActivity) {
+    constructor(db, emitActivity, options = {}) {
         this.db = db;
         this.emitActivity = emitActivity;
+        this.options = options;
     }
     maybeEmitProgress(notification, run) {
         const issue = this.db.getIssue(run.projectId, run.linearIssueId);
@@ -14,6 +17,7 @@ export class LinearProgressReporter {
         }
         const fact = deriveLinearProgressFact(notification, issue);
         if (!fact) {
+            this.maybeEmitHeartbeat(notification, run);
             return;
         }
         const previous = this.publicationsByRun.get(run.id);
@@ -22,9 +26,10 @@ export class LinearProgressReporter {
         if (!shouldEmitEphemeral && !shouldEmitHistory) {
             return;
         }
-        const now = Date.now();
+        const now = this.now();
         const publication = {
             ...previous,
+            quietSinceMs: now,
             ...(shouldEmitEphemeral
                 ? {
                     ephemeralMeaningKey: fact.meaningKey,
@@ -53,6 +58,56 @@ export class LinearProgressReporter {
     clearProgress(runId) {
         this.publicationsByRun.delete(runId);
     }
+    maybeEmitHeartbeat(notification, run) {
+        const previous = this.publicationsByRun.get(run.id);
+        const now = this.now();
+        const quietSinceMs = previous?.quietSinceMs ?? previous?.ephemeralPublishedAtMs ?? previous?.historyPublishedAtMs ?? now;
+        const elapsedMs = now - quietSinceMs;
+        const intervalMs = this.options.heartbeatIntervalMs ?? LinearProgressReporter.DEFAULT_HEARTBEAT_INTERVAL_MS;
+        if (elapsedMs < intervalMs) {
+            if (!previous) {
+                this.publicationsByRun.set(run.id, { quietSinceMs });
+            }
+            return;
+        }
+        if (previous?.lastHeartbeatAtMs !== undefined && now - previous.lastHeartbeatAtMs < intervalMs) {
+            return;
+        }
+        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+        if (!issue) {
+            return;
+        }
+        const detail = describeHeartbeatDetail(notification);
+        const content = {
+            type: "thought",
+            body: detail
+                ? `PatchRelay is still working on ${run.runType.replaceAll("_", " ")}. Latest signal: ${detail}.`
+                : `PatchRelay is still working on ${run.runType.replaceAll("_", " ")}.`,
+        };
+        this.publicationsByRun.set(run.id, {
+            ...previous,
+            quietSinceMs,
+            lastHeartbeatAtMs: now,
+        });
+        void this.emitActivity(issue, content, { ephemeral: true }).catch(() => {
+            const current = this.publicationsByRun.get(run.id);
+            if (current?.lastHeartbeatAtMs === now) {
+                const restored = {
+                    ...current,
+                };
+                if (previous?.lastHeartbeatAtMs !== undefined) {
+                    restored.lastHeartbeatAtMs = previous.lastHeartbeatAtMs;
+                }
+                else {
+                    delete restored.lastHeartbeatAtMs;
+                }
+                this.publicationsByRun.set(run.id, restored);
+            }
+        });
+    }
+    now() {
+        return this.options.now?.() ?? Date.now();
+    }
     clearFailedPublication(runId, channel, meaningKey, publishedAtMs) {
         const current = this.publicationsByRun.get(runId);
         if (!current) {
@@ -93,3 +148,27 @@ export class LinearProgressReporter {
         this.publicationsByRun.set(runId, next);
     }
 }
+function describeHeartbeatDetail(notification) {
+    if (notification.method === "item/started" || notification.method === "item/updated" || notification.method === "item/completed") {
+        const item = notification.params.item;
+        if (item && typeof item === "object") {
+            const typed = item;
+            if (typed.type === "commandExecution" && typeof typed.command === "string") {
+                return `command ${trimHeartbeatDetail(typed.command)}`;
+            }
+            if (typed.type === "dynamicToolCall" && typeof typed.tool === "string") {
+                return `tool ${trimHeartbeatDetail(typed.tool)}`;
+            }
+            if (typed.type === "mcpToolCall" && typeof typed.server === "string" && typeof typed.tool === "string") {
+                return `tool ${trimHeartbeatDetail(`${typed.server}/${typed.tool}`)}`;
+            }
+        }
+    }
+    return notification.method;
+}
+function trimHeartbeatDetail(value, maxLength = 120) {
+    const compact = value.replace(/\s+/g, " ").trim();
+    if (compact.length <= maxLength)
+        return compact;
+    return `${compact.slice(0, maxLength).trimEnd()}...`;
+}

package/dist/linear-session-reporting.js

@@ -61,7 +61,14 @@ export function buildBlockedDelegationActivity(blockedByKeys = []) {
 export function buildPromptDeliveredThought(runType) {
     return {
         type: "thought",
-        body: `PatchRelay routed your latest instructions into the active ${lowerRunTypeLabel(runType)} workflow.`,
+        body: `PatchRelay routed your latest instructions into the active ${lowerRunTypeLabel(runType)} workflow; it will fold them in at the next checkpoint.`,
+    };
+}
+export function buildPromptDeliveryFailedActivity(runType, reason) {
+    const suffix = reason ? ` ${trimSummary(reason, 180)}` : "";
+    return {
+        type: "thought",
+        body: `PatchRelay could not route your latest instructions into the active ${lowerRunTypeLabel(runType)} workflow.${suffix}`,
     };
 }
 export function buildFollowupStatusActivity(params) {
@@ -72,14 +79,16 @@ export function buildFollowupStatusActivity(params) {
     const prNote = params.issue.prNumber ? ` PR #${params.issue.prNumber}.` : "";
     const statusNote = params.statusNote ? ` ${params.statusNote}` : "";
     return {
-        type: "response",
+        type: params.activityType ?? "response",
         body: `PatchRelay status: ${subject} is ${formatFactoryState(params.issue.factoryState)}.${prNote}${runNote}${statusNote}`.trim(),
     };
 }
 export function buildNonActionableFollowupActivity(intent) {
     const body = intent === "status"
         ? "PatchRelay status is available in the current agent session."
-        : "PatchRelay did not start implementation because this looks like a question or clarification. Ask PatchRelay to continue, retry, or implement when you want work to run.";
+        : intent === "context_only"
+            ? "PatchRelay recorded this as context and did not start a new run. Ask PatchRelay to continue, retry, or implement when you want work to run."
+            : "PatchRelay did not start a run because this did not clearly request work. Ask PatchRelay to continue, retry, or implement when you want work to run.";
     return { type: "response", body };
 }
 export function buildRunStartedActivity(runType) {
@@ -97,6 +106,18 @@ export function buildRunStartedActivity(runType) {
             return { type: "action", action: "Implementing", parameter: "requested change" };
     }
 }
+export function buildReviewRoundStartedActivity(params) {
+    const reviewer = params.reviewerName ? ` from @${params.reviewerName}` : "";
+    const head = params.headSha ? ` on head ${params.headSha.slice(0, 8)}` : "";
+    const comments = params.commentCount !== undefined
+        ? `; ${params.commentCount} inline comment${params.commentCount === 1 ? "" : "s"} captured`
+        : "";
+    return {
+        type: "action",
+        action: "Review round",
+        parameter: `${params.round}${reviewer}${head}${comments}`,
+    };
+}
 function formatFactoryState(state) {
     return state.replaceAll("_", " ");
 }
@@ -104,44 +125,54 @@ export function buildRunCompletedActivity(params) {
     const prLabel = params.prNumber ? `PR #${params.prNumber}` : "the pull request";
     const summary = trimSummary(params.completionSummary);
     const detail = summary ? ` ${summary}` : "";
+    const steeringSummary = buildSteeringSummary(params.steeringDeliveredCount, params.steeringFailedCount);
     switch (params.runType) {
         case "implementation":
             if (params.postRunState === "pr_open") {
+                const body = `${prLabel} opened:${detail || " Published and ready for review."}`;
                 return {
                     type: "response",
-                    body: `${prLabel} opened:${detail || " Published and ready for review."}`,
+                    body: steeringSummary ? `${body}\n\n${steeringSummary}` : body,
                 };
             }
             return undefined;
         case "review_fix":
-            return summary
-                ? {
-                    type: "response",
-                    body: summary,
+            {
+                const lines = [];
+                lines.push(params.reviewRound ? `Review round ${params.reviewRound} completed.` : "Review fix completed.");
+                if (params.resultHeadSha)
+                    lines.push(`Resulting head: ${params.resultHeadSha.slice(0, 8)}.`);
+                if (steeringSummary)
+                    lines.push(steeringSummary);
+                const resolution = buildReviewResolutionSections(summary);
+                lines.push("", "Addressed:", resolution.addressed, "", "Deferred:", resolution.deferred, "", "Not applicable:", resolution.notApplicable);
+                if (!summary && !params.resultHeadSha) {
+                    lines[0] = `Updated ${prLabel} to address review feedback.`;
                 }
-                : {
+                return {
                     type: "response",
-                    body: `Updated ${prLabel} to address review feedback.`,
+                    body: lines.join("\n").trim(),
                 };
+            }
         case "ci_repair":
             return summary
                 ? {
                     type: "response",
-                    body: summary,
+                    body: steeringSummary ? `${summary}\n\n${steeringSummary}` : summary,
                 }
                 : {
                     type: "response",
-                    body: `Updated ${prLabel} after CI repair.`,
+                    body: steeringSummary ? `Updated ${prLabel} after CI repair.\n\n${steeringSummary}` : `Updated ${prLabel} after CI repair.`,
                 };
         case "queue_repair":
             return summary
                 ? {
                     type: "response",
-                    body: summary,
+                    body: steeringSummary ? `${summary}\n\n${steeringSummary}` : summary,
                 }
                 : {
                     type: "response",
-                    body: `Updated ${prLabel} after merge-queue repair.`,
+                    body: steeringSummary ? `Updated ${prLabel} after merge-queue repair.\n\n${steeringSummary}` : `Updated ${prLabel} after merge-queue repair.`,
                 };
         case "branch_upkeep":
             return undefined;
@@ -155,6 +186,9 @@ export function buildRunCompletedActivity(params) {
             if (summary) {
                 lines.push("", summary);
             }
+            if (steeringSummary) {
+                lines.push("", steeringSummary);
+            }
             return {
                 type: "response",
                 body: lines.join("\n"),
@@ -162,6 +196,32 @@ export function buildRunCompletedActivity(params) {
         }
     }
 }
+function buildSteeringSummary(delivered = 0, failed = 0) {
+    if (delivered === 0 && failed === 0)
+        return undefined;
+    const parts = [];
+    if (delivered > 0) {
+        parts.push(`${delivered} follow-up prompt${delivered === 1 ? "" : "s"} delivered`);
+    }
+    if (failed > 0) {
+        parts.push(`${failed} follow-up delivery failure${failed === 1 ? "" : "s"}`);
+    }
+    return `Steering: ${parts.join("; ")}.`;
+}
+function buildReviewResolutionSections(summary) {
+    if (!summary) {
+        return {
+            addressed: "- Review feedback addressed and published.",
+            deferred: "- None reported.",
+            notApplicable: "- None reported.",
+        };
+    }
+    return {
+        addressed: `- ${summary}`,
+        deferred: "- None reported.",
+        notApplicable: "- None reported.",
+    };
+}
 export function buildRunFailureActivity(runType, reason) {
     const label = formatRunTypeLabel(runType);
     return {

package/dist/manual-issue-actions.js

@@ -6,6 +6,11 @@ export function resolveRetryTarget(params) {
     if (hasOpenPr(params.prNumber, params.prState) && params.lastGitHubFailureSource === "queue_eviction") {
         return { runType: "queue_repair", factoryState: "repairing_queue" };
     }
+    if (hasOpenPr(params.prNumber, params.prState)
+        && params.prReviewState === "approved"
+        && (params.factoryState === "awaiting_queue" || params.lastRunType === "queue_repair")) {
+        return { runType: "queue_repair", factoryState: "repairing_queue" };
+    }
     if (hasOpenPr(params.prNumber, params.prState)
         && (params.prCheckStatus === "failed" || params.prCheckStatus === "failure" || params.lastGitHubFailureSource === "branch_ci")) {
         return { runType: "ci_repair", factoryState: "repairing_ci" };

package/dist/operator-retry-event.js

@@ -19,6 +19,13 @@ export function buildOperatorRetryEvent(issue, runType, source = "operator_retry
                 ...(queueIncident ?? {}),
                 ...(failureContext ?? {}),
                 source,
+                requiresFreshHead: true,
+                promptContext: [
+                    "Operator retry is recovering a merge queue rejection on an approved PR.",
+                    "If the previous repair left the same head SHA in place, merge-steward may still consider it terminally evicted.",
+                    "Preserve the approved diff, but publish a new head SHA on the existing PR branch before finishing.",
+                    "If rebasing onto the current base produces no content change, create an empty queue-kick commit.",
+                ].join(" "),
             }),
             dedupeKey: `${source}:queue_repair:${issue.linearIssueId}:${issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown-sha"}`,
         };

package/dist/prompting/patchrelay.js

@@ -266,10 +266,17 @@ function buildStructuredReviewContext(context) {
     const reviewCommitId = typeof context?.reviewCommitId === "string" ? context.reviewCommitId : undefined;
     const reviewUrl = typeof context?.reviewUrl === "string" ? context.reviewUrl : undefined;
     const reviewComments = readReviewFixComments(context);
-    if (!reviewId && !reviewCommitId && !reviewUrl && reviewComments.length === 0) {
+    const degraded = context?.reviewContextDegraded === true;
+    if (!degraded && !reviewId && !reviewCommitId && !reviewUrl && reviewComments.length === 0) {
         return undefined;
     }
     const lines = ["## Structured Review Context", ""];
+    if (degraded) {
+        const reason = typeof context?.reviewContextDegradedReason === "string" && context.reviewContextDegradedReason.trim()
+            ? context.reviewContextDegradedReason.trim()
+            : "GitHub requested-changes context could not be refreshed before launch.";
+        lines.push("GitHub review context refresh: degraded", reason, "Do not assume cached review details are current. Re-read the PR review in GitHub before making review-fix changes.");
+    }
     if (reviewId !== undefined)
         lines.push(`Review ID: ${reviewId}`);
     if (reviewCommitId)
@@ -436,6 +443,22 @@ function buildFollowUpContextLines(issue, runType, context) {
         lines.push("", "Recent updates:");
         followUpLines.forEach((line) => lines.push(`- ${line}`));
     }
+    if (context?.replacementPrRequired === true) {
+        lines.push("", "Previous PR facts:");
+        if (typeof context.previousPrNumber === "number") {
+            lines.push(`Previous PR: #${context.previousPrNumber} (replacement PR needed)`);
+        }
+        if (typeof context.previousPrUrl === "string") {
+            lines.push(`Previous PR URL: ${context.previousPrUrl}`);
+        }
+        if (typeof context.previousPrState === "string") {
+            lines.push(`Previous PR state: ${context.previousPrState}`);
+        }
+        if (typeof context.previousPrHeadSha === "string") {
+            lines.push(`Previous PR head SHA: ${context.previousPrHeadSha}`);
+        }
+        lines.push("Create a fresh replacement PR for the new requested changes; do not mutate or republish the completed PR.");
+    }
     if (issue.prNumber || issue.prHeadSha || issue.prReviewState || context?.mergeStateStatus) {
         const prHeading = prContext.kind === "closed_historical_pr"
             || prContext.kind === "closed_replacement_pending"
@@ -531,7 +554,7 @@ function buildPrePushSelfReviewSection(target, runType) {
     }
     return lines;
 }
-function buildPublicationContract(runType, issueClass) {
+function buildPublicationContract(runType, issueClass, context) {
     if (issueClass === "orchestration") {
         return [
             "## Publish",
@@ -554,6 +577,7 @@ function buildPublicationContract(runType, issueClass) {
             ...buildPrePushSelfReviewSection("new_pr", runType),
         ].join("\n");
     }
+    const requiresFreshQueueHead = runType === "queue_repair" && context?.requiresFreshHead === true;
     return [
         "## Publish",
         "",
@@ -561,8 +585,16 @@ function buildPublicationContract(runType, issueClass) {
         "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.",
         "",
-        "Before pushing, compute `git diff $(git merge-base origin/main HEAD)..HEAD | git patch-id --stable` and compare its first field to the `Last published patch-id` shown in the prompt header (if any).",
-        "If they match, do not push — finish the run as a no-op. Edit the PR body via `gh pr edit` instead if a textual update is needed.",
+        ...(requiresFreshQueueHead
+            ? [
+                "This queue repair requires a fresh PR head SHA because the previous head was terminally evicted by merge-steward.",
+                "Before pushing, compute `git diff $(git merge-base origin/main HEAD)..HEAD | git patch-id --stable` and compare its first field to the `Last published patch-id` shown in the prompt header (if any).",
+                "If the patch-id matches, preserve the approved diff and still push a new head SHA on the existing PR branch. Prefer a real rebase onto current `origin/main`; if that produces no content change, create an empty queue-kick commit.",
+            ]
+            : [
+                "Before pushing, compute `git diff $(git merge-base origin/main HEAD)..HEAD | git patch-id --stable` and compare its first field to the `Last published patch-id` shown in the prompt header (if any).",
+                "If they match, do not push — finish the run as a no-op. Edit the PR body via `gh pr edit` instead if a textual update is needed.",
+            ]),
         "",
         ...buildPrePushSelfReviewSection("existing_pr", runType),
     ].join("\n");
@@ -586,7 +618,7 @@ function buildSections(issue, runType, repoPath, context, followUp = false) {
     if (workflow) {
         sections.push({ id: "workflow-guidance", content: workflow });
     }
-    sections.push({ id: "publication-contract", content: buildPublicationContract(runType, issueClass) });
+    sections.push({ id: "publication-contract", content: buildPublicationContract(runType, issueClass, context) });
     return sections;
 }
 function filterAllowedReplacements(promptLayer) {
@@ -654,8 +686,8 @@ export function mergePromptCustomizationLayers(base, override) {
                 ? { extraInstructions: base.extraInstructions }
                 : {}),
         replaceSections: {
-            ...(base?.replaceSections ?? {}),
-            ...(override?.replaceSections ?? {}),
+            ...base?.replaceSections,
+            ...override?.replaceSections,
         },
     };
 }

package/dist/queue-health-monitor.js

@@ -12,6 +12,8 @@ function isDuplicateProbe(issue, context) {
     const headSha = typeof context?.failureHeadSha === "string" ? context.failureHeadSha : undefined;
     if (!signature)
         return false;
+    if (context?.requiresFreshHead === true)
+        return false;
     return issue.lastAttemptedFailureSignature === signature
         && (headSha === undefined || issue.lastAttemptedFailureHeadSha === headSha);
 }
@@ -133,12 +135,25 @@ export class QueueHealthMonitor {
         if (isDirty || hasEvictionCheckRun) {
             const headRefOid = pr.headRefOid ?? "unknown";
             const reason = hasEvictionCheckRun ? "queue_eviction_missed" : "preemptive_conflict";
-            const signature = `preemptive_queue_conflict:${headRefOid}`;
+            const signature = hasEvictionCheckRun
+                ? `same_head_queue_eviction:${headRefOid}`
+                : `preemptive_queue_conflict:${headRefOid}`;
             const pendingRunContext = {
                 source: "queue_health_monitor",
                 failureReason: reason,
                 failureHeadSha: headRefOid,
                 failureSignature: signature,
+                ...(hasEvictionCheckRun
+                    ? {
+                        requiresFreshHead: true,
+                        promptContext: [
+                            `merge-steward/queue is already failed on PR #${issue.prNumber} at head ${headRefOid}.`,
+                            "merge-steward will not re-admit the same evicted head SHA.",
+                            "Preserve the approved diff, but publish a new head SHA on the existing PR branch before finishing.",
+                            "If rebasing onto the current base produces no content change, create an empty queue-kick commit.",
+                        ].join(" "),
+                    }
+                    : {}),
             };
             if (isDuplicateProbe(issue, pendingRunContext)) {
                 return;

package/dist/reactive-run-policy.js

@@ -289,19 +289,24 @@ export class ReactiveRunPolicy {
         return updated;
     }
     async hydrateRequestedChangesContext(projectId, prNumber, repoFullName, headSha, context) {
-        const merged = {
-            ...(context ?? {}),
-            ...(headSha ? { headSha } : {}),
-        };
-        if (hasStructuredReviewContext(merged)) {
-            return merged;
+        const merged = { ...context };
+        if (headSha) {
+            merged.headSha = headSha;
+            merged.currentPrHeadSha = headSha;
         }
         const liveReview = await readLatestRequestedChangesReviewContext(repoFullName, prNumber);
         if (!liveReview) {
-            return Object.keys(merged).length > 0 ? merged : context;
+            return {
+                ...merged,
+                reviewContextStatus: "degraded",
+                reviewContextDegraded: true,
+                reviewContextDegradedReason: "GitHub requested-changes review context could not be fetched before launch.",
+            };
         }
         return {
             ...merged,
+            reviewContextStatus: "fresh",
+            reviewContextDegraded: false,
             ...(liveReview.reviewId !== undefined ? { reviewId: liveReview.reviewId } : {}),
             ...(liveReview.reviewCommitId ? { reviewCommitId: liveReview.reviewCommitId } : {}),
             ...(liveReview.reviewUrl ? { reviewUrl: liveReview.reviewUrl } : {}),
@@ -327,21 +332,3 @@ function isReactiveScopeRiskPath(filePath) {
     return REACTIVE_SCOPE_RISK_EXACT_PATHS.has(filePath)
         || REACTIVE_SCOPE_RISK_PREFIXES.some((prefix) => filePath.startsWith(prefix));
 }
-function hasStructuredReviewContext(context) {
-    if (!context)
-        return false;
-    const reviewBody = typeof context.reviewBody === "string" ? context.reviewBody.trim() : "";
-    const isOperatorRetryPlaceholder = typeof context.source === "string"
-        && context.source === "operator_retry"
-        && /^operator requested retry of review-fix work\.?$/i.test(reviewBody);
-    if (isOperatorRetryPlaceholder) {
-        return false;
-    }
-    if (reviewBody)
-        return true;
-    if (typeof context.reviewUrl === "string" && context.reviewUrl.trim())
-        return true;
-    if (typeof context.reviewerName === "string" && context.reviewerName.trim())
-        return true;
-    return Array.isArray(context.reviewComments) && context.reviewComments.length > 0;
-}

package/dist/run-finalizer.js

@@ -20,6 +20,24 @@ function buildRunSummaryJson(report, publicationRecapSummary) {
         publicationRecapSummary: publicationRecapSummary ?? null,
     });
 }
+function summarizePromptDeliveryEvents(events, run) {
+    let delivered = 0;
+    let failed = 0;
+    for (const event of events) {
+        if (event.eventType !== "prompt_delivered")
+            continue;
+        const payload = parseEventJson(event.eventJson);
+        if (payload?.runId !== run.id)
+            continue;
+        if (payload.status === "delivered") {
+            delivered += 1;
+        }
+        else if (payload.status === "delivery_failed") {
+            failed += 1;
+        }
+    }
+    return { delivered, failed };
+}
 function shouldGeneratePublicationRecap(runType) {
     return runType === "implementation"
         || runType === "review_fix"
@@ -417,11 +435,16 @@ export class RunFinalizer {
         const completionSummary = publicationRecapSummary
             ?? report.assistantMessages.at(-1)?.slice(0, 300)
             ?? `${run.runType} completed.`;
+        const steeringSummary = summarizePromptDeliveryEvents(this.db.issueSessions.listIssueSessionEvents(run.projectId, run.linearIssueId), run);
         const linearActivity = buildRunCompletedActivity({
             runType: run.runType,
             completionSummary,
             postRunState: updatedIssue.factoryState,
             ...(updatedIssue.prNumber !== undefined ? { prNumber: updatedIssue.prNumber } : {}),
+            ...(run.runType === "review_fix" ? { reviewRound: Math.max(1, updatedIssue.reviewFixAttempts) } : {}),
+            ...(run.runType === "review_fix" && updatedIssue.prHeadSha ? { resultHeadSha: updatedIssue.prHeadSha } : {}),
+            ...(steeringSummary.delivered > 0 ? { steeringDeliveredCount: steeringSummary.delivered } : {}),
+            ...(steeringSummary.failed > 0 ? { steeringFailedCount: steeringSummary.failed } : {}),
         });
         if (linearActivity) {
             void this.linearSync.emitActivity(updatedIssue, linearActivity);

package/dist/run-orchestrator.js

@@ -1,5 +1,5 @@
 import { summarizeCurrentThread } from "./run-reporting.js";
-import { buildRunStartedActivity, } from "./linear-session-reporting.js";
+import { buildReviewRoundStartedActivity, buildRunStartedActivity, } from "./linear-session-reporting.js";
 import { CompletionCheckService } from "./completion-check.js";
 import { PublicationRecapService } from "./publication-recap.js";
 import { WorktreeManager } from "./worktree-manager.js";
@@ -411,7 +411,16 @@ export class RunOrchestrator {
         this.logger.info({ issueKey: issue.issueKey, runType, threadId, turnId }, `Started ${runType} run`);
         // Emit Linear activity + plan
         const freshIssue = this.db.issues.getIssue(item.projectId, item.issueId) ?? issue;
-        void this.linearSync.emitActivity(freshIssue, buildRunStartedActivity(runType));
+        const reviewComments = Array.isArray(effectiveContext?.reviewComments) ? effectiveContext.reviewComments : undefined;
+        const reviewRoundActivity = runType === "review_fix"
+            ? buildReviewRoundStartedActivity({
+                round: Math.max(1, freshIssue.reviewFixAttempts),
+                ...(typeof effectiveContext?.reviewerName === "string" ? { reviewerName: effectiveContext.reviewerName } : {}),
+                ...(reviewComments ? { commentCount: reviewComments.length } : {}),
+                ...(typeof sourceHeadSha === "string" ? { headSha: sourceHeadSha } : {}),
+            })
+            : undefined;
+        void this.linearSync.emitActivity(freshIssue, reviewRoundActivity ?? buildRunStartedActivity(runType));
         void this.linearSync.syncSession(freshIssue, { activeRunType: runType });
     }
     async resetWorktreeToTrackedBranch(worktreePath, branchName, issue) {

package/dist/service-issue-actions.js

@@ -108,6 +108,7 @@ export class ServiceIssueActions {
             prState: issue.prState,
             prReviewState: issue.prReviewState,
             prCheckStatus: issue.prCheckStatus,
+            factoryState: issue.factoryState,
             pendingRunType: issue.pendingRunType,
             lastRunType: issueSession?.lastRunType,
             lastGitHubFailureSource: issue.lastGitHubFailureSource,

package/dist/webhook-handler.js

@@ -12,6 +12,8 @@ import { IssueRemovalHandler } from "./webhooks/issue-removal-handler.js";
 import { safeJsonParse, sanitizeDiagnosticText } from "./utils.js";
 import { extractLatestAssistantSummary } from "./issue-session-events.js";
 import { WakeDispatcher } from "./wake-dispatcher.js";
+import { CodexFollowupIntentClassifier } from "./followup-intent.js";
+import { CodexConversationAdapter } from "./codex-conversation-adapter.js";
 export class WebhookHandler {
     config;
     db;
@@ -28,7 +30,7 @@ export class WebhookHandler {
     dependencyReadinessHandler;
     linearSync;
     wakeDispatcher;
-    constructor(config, db, linearProvider, codex, wakeDispatcherOrEnqueueIssue, logger, feed) {
+    constructor(config, db, linearProvider, codex, wakeDispatcherOrEnqueueIssue, logger, feed, followupClassifier) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
@@ -44,11 +46,13 @@ export class WebhookHandler {
             : new WakeDispatcher(db, wakeDispatcherOrEnqueueIssue, () => undefined, logger, feed);
         this.installationHandler = new InstallationWebhookHandler(config, { linearInstallations: db.linearInstallations }, logger, feed);
         this.issueRemovalHandler = new IssueRemovalHandler(db, feed);
-        this.commentWakeHandler = new CommentWakeHandler(db, codex, this.wakeDispatcher, logger, feed);
-        this.agentSessionHandler = new AgentSessionHandler(config, db, linearProvider, codex, this.wakeDispatcher, logger, feed);
+        this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
+        const intentClassifier = followupClassifier ?? new CodexFollowupIntentClassifier(codex, logger);
+        const conversationAdapter = new CodexConversationAdapter(db, codex, this.wakeDispatcher, logger, feed, intentClassifier);
+        this.commentWakeHandler = new CommentWakeHandler(db, this.wakeDispatcher, feed, conversationAdapter, (issue, content, options) => this.linearSync.emitActivity(issue, content, options));
+        this.agentSessionHandler = new AgentSessionHandler(config, db, linearProvider, codex, this.wakeDispatcher, logger, feed, conversationAdapter);
         this.desiredStageRecorder = new DesiredStageRecorder(db, linearProvider, this.wakeDispatcher, feed);
         this.contextLoader = new WebhookContextLoader(config, linearProvider);
-        this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
         this.dependencyReadinessHandler = new DependencyReadinessHandler(db, this.wakeDispatcher, (projectId, issueId) => this.peekPendingSessionWakeRunType(projectId, issueId));
     }
     async processWebhookEvent(webhookEventId) {