patchrelay 0.68.7 → 0.69.1

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/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"
@@ -663,8 +686,8 @@ export function mergePromptCustomizationLayers(base, override) {
                 ? { extraInstructions: base.extraInstructions }
                 : {}),
         replaceSections: {
-            ...(base?.replaceSections ?? {}),
-            ...(override?.replaceSections ?? {}),
+            ...base?.replaceSections,
+            ...override?.replaceSections,
         },
     };
 }

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/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) {

package/dist/webhooks/agent-session-handler.js

@@ -1,10 +1,7 @@
 import { buildAgentSessionPlanForIssue, } from "../agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "../agent-session-presentation.js";
-import { classifyFollowupIntent, followupIntentIsNonActionable } from "../followup-intent.js";
-import { extractLatestAssistantSummary } from "../issue-session-events.js";
-import { buildAlreadyRunningThought, buildAgentSessionAcknowledgementThought, buildBlockedDelegationActivity, buildDelegationThought, buildFollowupStatusActivity, buildNonActionableFollowupActivity, buildPromptDeliveredThought, buildStopConfirmationActivity, } from "../linear-session-reporting.js";
+import { buildAlreadyRunningThought, buildAgentSessionAcknowledgementThought, buildBlockedDelegationActivity, buildDelegationThought, buildStopConfirmationActivity, } from "../linear-session-reporting.js";
 import { resolveProject, triggerEventAllowed } from "../project-resolution.js";
-import { deriveIssueStatusNote } from "../status-note.js";
 const PATCHRELAY_AGENT_ACTIVITY_TYPES = new Set([
     "action",
     "elicitation",
@@ -20,7 +17,8 @@ export class AgentSessionHandler {
     wakeDispatcher;
     logger;
     feed;
-    constructor(config, db, linearProvider, codex, wakeDispatcher, logger, feed) {
+    conversationAdapter;
+    constructor(config, db, linearProvider, codex, wakeDispatcher, logger, feed, conversationAdapter) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
@@ -28,6 +26,7 @@ export class AgentSessionHandler {
         this.wakeDispatcher = wakeDispatcher;
         this.logger = logger;
         this.feed = feed;
+        this.conversationAdapter = conversationAdapter;
     }
     async acknowledgeCreated(normalized) {
         if (normalized.triggerEvent !== "agentSessionCreated" || !normalized.agentSession?.id || !normalized.issue) {
@@ -65,7 +64,6 @@ export class AgentSessionHandler {
             return;
         const existingIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
         const activeRun = existingIssue?.activeRunId ? this.db.runs.getRunById(existingIssue.activeRunId) : undefined;
-        const automationEnabled = delegated || existingIssue?.delegatedToPatchRelay === true;
         if (normalized.triggerEvent === "agentSessionCreated") {
             if (!delegated) {
                 const latestIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
@@ -128,78 +126,23 @@ export class AgentSessionHandler {
         }
         const promptBody = normalized.agentSession.promptBody?.trim();
         const directReply = promptBody && existingIssue ? params.isDirectReplyToOutstandingQuestion(existingIssue) : false;
-        const promptIntent = promptBody ? classifyFollowupIntent(promptBody) : undefined;
-        if (promptBody && existingIssue && promptIntent === "stop") {
-            await this.handleStopSignal({
-                normalized,
+        if (promptBody && existingIssue && this.conversationAdapter) {
+            const result = await this.conversationAdapter.deliverAgentInput({
                 project,
-                trackedIssue,
-                activeRun,
-                linear,
-                syncAgentSession: (agentSessionId, issue, options) => this.syncAgentSession(linear, agentSessionId, issue, params.peekPendingSessionWakeRunType, options),
-            });
-            return;
-        }
-        if (promptBody && existingIssue && promptIntent === "status" && !directReply) {
-            await this.publishAgentActivity(linear, normalized.agentSession.id, this.buildStatusActivity(existingIssue, activeRun, params.peekPendingSessionWakeRunType));
-            await this.syncAgentSession(linear, normalized.agentSession.id, existingIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, activeRun ? { activeRunType: activeRun.runType } : undefined);
-            return;
-        }
-        if (promptBody && promptIntent && followupIntentIsNonActionable(promptIntent) && !directReply) {
-            await this.publishAgentActivity(linear, normalized.agentSession.id, buildNonActionableFollowupActivity(promptIntent));
-            return;
-        }
-        if (!automationEnabled && promptBody && existingIssue) {
-            await this.publishAgentActivity(linear, normalized.agentSession.id, {
-                type: "thought",
-                body: "PatchRelay is paused because the issue is undelegated.",
-            }, { ephemeral: true });
-            return;
-        }
-        if (activeRun && promptBody && activeRun.threadId && activeRun.turnId) {
-            const input = `New Linear agent prompt received while you are working.\n\n${promptBody}`;
-            try {
-                await this.codex.steerTurn({ threadId: activeRun.threadId, turnId: activeRun.turnId, input });
-                this.feed?.publish({
-                    level: "info",
-                    kind: "agent",
-                    projectId: project.id,
-                    issueKey: trackedIssue?.issueKey,
-                    stage: activeRun.runType,
-                    status: "delivered",
-                    summary: `Delivered follow-up prompt to active ${activeRun.runType} workflow`,
-                });
-            }
-            catch (error) {
-                this.logger.warn({ issueKey: trackedIssue?.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to deliver follow-up prompt");
-                this.feed?.publish({
-                    level: "warn",
-                    kind: "agent",
-                    projectId: project.id,
-                    issueKey: trackedIssue?.issueKey,
-                    stage: activeRun.runType,
-                    status: "delivery_failed",
-                    summary: `Could not deliver follow-up prompt to active ${activeRun.runType} workflow`,
-                });
-            }
-            await this.publishAgentActivity(linear, normalized.agentSession.id, buildPromptDeliveredThought(activeRun.runType), { ephemeral: true });
-            return;
-        }
-        if (promptBody && existingIssue && automationEnabled) {
-            if (!directReply && promptIntent && followupIntentIsNonActionable(promptIntent)) {
-                await this.publishAgentActivity(linear, normalized.agentSession.id, buildNonActionableFollowupActivity(promptIntent));
-                return;
-            }
-            const queuedRunType = this.wakeDispatcher.recordEventAndDispatch(project.id, normalized.issue.id, {
-                eventType: directReply ? "direct_reply" : "followup_prompt",
-                eventJson: JSON.stringify({
-                    text: promptBody,
-                    source: "linear_agent_prompt",
-                }),
+                issue: existingIssue,
+                source: "agent_session_prompt",
+                body: promptBody,
+                directReply,
+                emitActivity: (content, options) => this.publishAgentActivity(linear, normalized.agentSession.id, content, options),
+                peekPendingSessionWakeRunType: params.peekPendingSessionWakeRunType,
             });
             const latestIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
-            await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, { pendingRunType: queuedRunType ?? wakeRunType ?? (existingIssue.prReviewState === "changes_requested" ? "review_fix" : "implementation") });
-            await this.publishAgentActivity(linear, normalized.agentSession.id, buildPromptDeliveredThought(queuedRunType ?? wakeRunType ?? "implementation"), { ephemeral: true });
+            const syncOptions = result.activeRunType
+                ? { activeRunType: result.activeRunType }
+                : result.queuedRunType ? { pendingRunType: result.queuedRunType }
+                    : wakeRunType ? { pendingRunType: wakeRunType }
+                        : undefined;
+            await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, syncOptions);
             return;
         }
         if (wakeRunType) {
@@ -208,24 +151,6 @@ export class AgentSessionHandler {
             await this.publishAgentActivity(linear, normalized.agentSession.id, buildDelegationThought(wakeRunType, "prompt"), { ephemeral: true });
         }
     }
-    buildStatusActivity(issue, activeRun, peekPendingSessionWakeRunType) {
-        const latestRun = activeRun ?? this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
-        const latestEvent = this.db.issueSessions.listIssueSessionEvents(issue.projectId, issue.linearIssueId).at(-1);
-        const statusNote = deriveIssueStatusNote({
-            issue,
-            latestRun,
-            latestEvent,
-            sessionSummary: extractLatestAssistantSummary(latestRun),
-            waitingReason: undefined,
-        });
-        const pendingRunType = peekPendingSessionWakeRunType(issue.projectId, issue.linearIssueId);
-        return buildFollowupStatusActivity({
-            issue,
-            ...(statusNote ? { statusNote } : {}),
-            ...(activeRun?.runType ? { activeRunType: activeRun.runType } : {}),
-            ...(pendingRunType ? { pendingRunType } : {}),
-        });
-    }
     async handleStopSignal(params) {
         const issueId = params.normalized.issue.id;
         const sessionId = params.normalized.agentSession.id;