patchrelay 0.68.6 → 0.69.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.68.6",
-  "commit": "b47d248df282",
-  "builtAt": "2026-05-19T20:34:54.989Z"
+  "version": "0.69.0",
+  "commit": "e4b7cc05aa47",
+  "builtAt": "2026-05-22T11:30:36.298Z"
 }

package/dist/cli/data.js

@@ -220,6 +220,7 @@ export class CliDataAccess extends CliOperatorApiClient {
                 prState: dbIssue.prState,
                 prReviewState: dbIssue.prReviewState,
                 prCheckStatus: dbIssue.prCheckStatus,
+                factoryState: dbIssue.factoryState,
                 pendingRunType: dbIssue.pendingRunType,
                 lastRunType: issueSession?.lastRunType,
                 lastGitHubFailureSource: issue.latestFailureSource,

package/dist/codex-app-server.js

@@ -24,6 +24,13 @@ const ISSUE_TRIAGE_DEVELOPER_INSTRUCTIONS = [
     "Use only the facts in the current prompt.",
     "Return only the requested JSON object.",
 ].join("\n");
+const FOLLOWUP_INTENT_DEVELOPER_INSTRUCTIONS = [
+    "You are PatchRelay's follow-up intent classifier.",
+    "This is a read-only routing step used only to classify one human Linear follow-up.",
+    "Do not run commands, do not call tools, do not edit files, and do not inspect or modify the repository.",
+    "Use only the text and state facts in the current prompt.",
+    "Return only the requested JSON object.",
+].join("\n");
 export function resolveCodexAppServerLaunch(config) {
     if (!config.sourceBashrc) {
         return {
@@ -121,6 +128,17 @@ export class CodexAppServerClient extends EventEmitter {
             developerInstructions: ISSUE_TRIAGE_DEVELOPER_INSTRUCTIONS,
         });
     }
+    async startThreadForFollowupIntent() {
+        return await this.startThreadWithOverrides({ cwd: tmpdir() }, {
+            approvalPolicy: "never",
+            sandboxMode: "read-only",
+            model: this.config.triageModel ?? "gpt-5.4-mini",
+            modelProvider: this.config.triageModelProvider ?? this.config.modelProvider ?? null,
+            reasoningEffort: "low",
+            baseInstructions: null,
+            developerInstructions: FOLLOWUP_INTENT_DEVELOPER_INSTRUCTIONS,
+        });
+    }
     async startThreadWithOverrides(options, overrides) {
         const params = {
             cwd: options.cwd,

package/dist/codex-conversation-adapter.js

@@ -0,0 +1,270 @@
+import { buildFollowupStatusActivity, buildNonActionableFollowupActivity, buildPromptDeliveryFailedActivity, buildPromptDeliveredThought, } from "./linear-session-reporting.js";
+import { deriveIssueStatusNote } from "./status-note.js";
+import { extractLatestAssistantSummary } from "./issue-session-events.js";
+export class CodexConversationAdapter {
+    db;
+    codex;
+    wakeDispatcher;
+    logger;
+    feed;
+    followupClassifier;
+    constructor(db, codex, wakeDispatcher, logger, feed, followupClassifier) {
+        this.db = db;
+        this.codex = codex;
+        this.wakeDispatcher = wakeDispatcher;
+        this.logger = logger;
+        this.feed = feed;
+        this.followupClassifier = followupClassifier;
+    }
+    async deliverAgentInput(params) {
+        const body = params.body.trim();
+        if (!body)
+            return { status: "ignored" };
+        const issue = this.db.issues.getIssue(params.issue.projectId, params.issue.linearIssueId) ?? params.issue;
+        const activeRun = issue.activeRunId ? this.db.runs.getRunById(issue.activeRunId) : undefined;
+        const intent = await this.classify(body, params.source, issue, activeRun, params.directReply === true);
+        if (intent?.intent === "status" && !params.directReply) {
+            await params.emitActivity?.(this.buildStatusActivity(issue, activeRun, params.peekPendingSessionWakeRunType, activeRun ? "thought" : "response"), activeRun ? { ephemeral: true } : undefined);
+            return { status: "answered", ...(activeRun?.runType ? { activeRunType: activeRun.runType } : {}) };
+        }
+        if (intent?.intent === "stop") {
+            if (activeRun) {
+                await this.stopActiveRun(issue, activeRun, body, params.source);
+            }
+            else {
+                this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
+                    eventType: "stop_requested",
+                    eventJson: JSON.stringify({ body, source: params.source, ...(params.author ? { author: params.author } : {}) }),
+                });
+                this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+            }
+            return { status: "stopped", ...(activeRun?.runType ? { activeRunType: activeRun.runType } : {}) };
+        }
+        if (!issue.delegatedToPatchRelay) {
+            await params.emitActivity?.({ type: "thought", body: "PatchRelay is paused because the issue is undelegated." }, { ephemeral: true });
+            return { status: "ignored" };
+        }
+        if (activeRun) {
+            return await this.steerActiveRun({
+                issue,
+                activeRun,
+                body,
+                source: params.source,
+                author: params.author,
+                emitActivity: params.emitActivity,
+            });
+        }
+        return await this.queueIdleInput({
+            project: params.project,
+            issue,
+            body,
+            source: params.source,
+            author: params.author,
+            directReply: params.directReply === true,
+            emitActivity: params.emitActivity,
+        });
+    }
+    async classify(body, source, issue, activeRun, directReply) {
+        if (!this.followupClassifier)
+            return undefined;
+        return await this.followupClassifier.classify(body, {
+            source: source === "agent_session_prompt" ? "agentPrompted" : "comment",
+            ...(activeRun?.runType ? { activeRunType: activeRun.runType } : {}),
+            factoryState: issue.factoryState,
+            directReply,
+            delegatedToPatchRelay: issue.delegatedToPatchRelay,
+            prReviewState: issue.prReviewState,
+            explicitWakeIntent: true,
+        });
+    }
+    async steerActiveRun(params) {
+        const { issue, activeRun, body, source } = params;
+        if (!activeRun.threadId || !activeRun.turnId) {
+            const queuedRunType = this.queueFollowUpEvent(issue, body, source, params.author, false);
+            return { status: "queued", ...(queuedRunType ? { queuedRunType } : {}) };
+        }
+        const input = [
+            source === "agent_session_prompt"
+                ? "New Linear agent-session prompt received while you are working."
+                : "New explicitly addressed Linear issue comment received while you are working.",
+            params.author ? `Author: ${params.author}` : undefined,
+            "",
+            "Checkpoint contract: incorporate this instruction before your next meaningful side effect when possible. If you are already inside a non-interruptible command, finish that command, then re-plan with this input before continuing.",
+            "",
+            body,
+        ].filter(Boolean).join("\n");
+        try {
+            await this.codex.steerTurn({ threadId: activeRun.threadId, turnId: activeRun.turnId, input });
+            this.recordPromptDelivery({
+                issue,
+                source,
+                runId: activeRun.id,
+                runType: activeRun.runType,
+                status: "delivered",
+                body,
+                primitive: "turn/steer",
+                threadId: activeRun.threadId,
+                turnId: activeRun.turnId,
+            });
+            this.feed?.publish({
+                level: "info",
+                kind: source === "agent_session_prompt" ? "agent" : "comment",
+                projectId: issue.projectId,
+                issueKey: issue.issueKey,
+                stage: activeRun.runType,
+                status: "delivered",
+                summary: `Delivered agent input to active ${activeRun.runType} workflow`,
+            });
+            await params.emitActivity?.(buildPromptDeliveredThought(activeRun.runType), { ephemeral: true });
+            return { status: "steered", activeRunType: activeRun.runType };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: issue.issueKey, error: message }, "Failed to deliver agent input to active Codex turn");
+            this.recordPromptDelivery({
+                issue,
+                source,
+                runId: activeRun.id,
+                runType: activeRun.runType,
+                status: "delivery_failed",
+                body,
+                primitive: "turn/steer",
+                threadId: activeRun.threadId,
+                turnId: activeRun.turnId,
+                error: message,
+            });
+            const queuedRunType = this.queueFollowUpEvent(issue, body, source, params.author, false);
+            this.feed?.publish({
+                level: "warn",
+                kind: source === "agent_session_prompt" ? "agent" : "comment",
+                projectId: issue.projectId,
+                issueKey: issue.issueKey,
+                stage: activeRun.runType,
+                status: "delivery_failed",
+                summary: `Could not deliver agent input to active ${activeRun.runType} workflow`,
+            });
+            await params.emitActivity?.(buildPromptDeliveryFailedActivity(activeRun.runType, message));
+            return { status: "delivery_failed", activeRunType: activeRun.runType, ...(queuedRunType ? { queuedRunType } : {}) };
+        }
+    }
+    async queueIdleInput(params) {
+        const originalIssue = params.issue;
+        let issue = originalIssue;
+        const replacementPrRequired = originalIssue.factoryState === "done" && originalIssue.prNumber !== undefined;
+        if (replacementPrRequired) {
+            issue = this.prepareReplacementWork(params.project, originalIssue);
+        }
+        const queuedRunType = this.queueFollowUpEvent(issue, params.body, params.source, params.author, params.directReply, replacementPrRequired ? originalIssue : undefined);
+        if (queuedRunType) {
+            await params.emitActivity?.(replacementPrRequired
+                ? { type: "action", action: "Reopening", parameter: `completed PR #${originalIssue.prNumber} for replacement work` }
+                : buildPromptDeliveredThought(queuedRunType), { ephemeral: true });
+        }
+        else {
+            await params.emitActivity?.(buildNonActionableFollowupActivity("unknown_needs_ack"));
+        }
+        return { status: queuedRunType ? "queued" : "ignored", ...(queuedRunType ? { queuedRunType } : {}) };
+    }
+    queueFollowUpEvent(issue, body, source, author, directReply, previousIssue) {
+        return this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
+            eventType: directReply ? "direct_reply" : source === "agent_session_prompt" ? "followup_prompt" : "followup_comment",
+            eventJson: JSON.stringify({
+                ...(source === "agent_session_prompt" ? { text: body } : { body }),
+                source: source === "agent_session_prompt" ? "linear_agent_prompt" : "linear_comment",
+                ...(author ? { author } : {}),
+                ...(previousIssue?.prNumber !== undefined
+                    ? {
+                        replacementPrRequired: true,
+                        previousPrNumber: previousIssue.prNumber,
+                        ...(previousIssue.prUrl ? { previousPrUrl: previousIssue.prUrl } : {}),
+                        ...(previousIssue.prState ? { previousPrState: previousIssue.prState } : {}),
+                        ...(previousIssue.prHeadSha ? { previousPrHeadSha: previousIssue.prHeadSha } : {}),
+                    }
+                    : {}),
+            }),
+        });
+    }
+    prepareReplacementWork(project, issue) {
+        const issueRef = (issue.issueKey ?? issue.linearIssueId).replace(/[^a-zA-Z0-9._-]+/g, "-");
+        const suffix = Date.now().toString(36);
+        return this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            factoryState: "delegated",
+            branchName: `${project.branchPrefix}/${issueRef}-replacement-${suffix}`,
+            prNumber: null,
+            prUrl: null,
+            prState: null,
+            prIsDraft: null,
+            prHeadSha: null,
+            prAuthorLogin: null,
+            prReviewState: null,
+            prCheckStatus: null,
+            lastBlockingReviewHeadSha: null,
+        }) ?? issue;
+    }
+    async stopActiveRun(issue, run, body, source) {
+        if (run.threadId && run.turnId) {
+            try {
+                await this.codex.steerTurn({
+                    threadId: run.threadId,
+                    turnId: run.turnId,
+                    input: "STOP: The user has requested you stop working immediately. Do not make further changes. Wrap up and exit.",
+                });
+            }
+            catch (error) {
+                this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to steer Codex turn for stop request");
+            }
+            this.db.runs.finishRun(run.id, { status: "released", threadId: run.threadId, turnId: run.turnId });
+        }
+        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            activeRunId: null,
+            factoryState: "awaiting_input",
+        });
+        this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
+            eventType: "stop_requested",
+            eventJson: JSON.stringify({ body, source }),
+        });
+        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+        this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
+    }
+    buildStatusActivity(issue, activeRun, peekPendingSessionWakeRunType, activityType) {
+        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 } : {}),
+            activityType,
+        });
+    }
+    recordPromptDelivery(params) {
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.issue.projectId, params.issue.linearIssueId, {
+            projectId: params.issue.projectId,
+            linearIssueId: params.issue.linearIssueId,
+            eventType: "prompt_delivered",
+            eventJson: JSON.stringify({
+                source: params.source === "agent_session_prompt" ? "linear_agent_prompt" : "linear_comment",
+                runId: params.runId,
+                runType: params.runType,
+                status: params.status,
+                body: params.body,
+                primitive: params.primitive,
+                ...(params.threadId ? { threadId: params.threadId } : {}),
+                ...(params.turnId ? { turnId: params.turnId } : {}),
+                ...(params.error ? { error: params.error } : {}),
+            }),
+        });
+    }
+}

package/dist/followup-intent.js

@@ -1,56 +1,169 @@
-const IMPLEMENTATION_PATTERNS = [
-    /\b(add|address|adjust|change|create|delete|deploy|fix|implement|install|merge|open|polish|publish|push|remove|rename|set|ship|update)\b/i,
-    /\b(go on and|go ahead and|please|pls)\s+\b(add|address|adjust|change|create|delete|deploy|fix|implement|install|merge|open|polish|publish|push|remove|rename|set|ship|update|use)\b/i,
-    /\b(use|keep|switch|move)\b.+\b(instead|copy|api|contract|behavior|state|repo|branch|team|issue|pr)\b/i,
-];
-const RETRY_PATTERNS = [
-    /\b(continue|go on|keep going|proceed|resume)\b/i,
-    /\b(retry|try again|rerun|run again|restart)\b/i,
-    /\b(next task|next issue)\b/i,
-];
-const STOP_PATTERNS = [
-    /\b(stop|cancel|halt|abort)\b/i,
-    /\b(pause|hold)\s+(work|implementation|the run|patchrelay)\b/i,
-    /\bdo not\s+(continue|proceed|work|implement)\b/i,
-];
-const STATUS_PATTERNS = [
-    /\b(status|progress)\b/i,
-    /\b(status update|progress update|any update|quick update)\b/i,
-    /\b(where are we|what'?s happening|what is happening|what'?s deployed|what is deployed)\b/i,
-    /\b(done so far|deployed so far|current work|current run)\b/i,
-];
-const CLARIFICATION_PATTERNS = [
-    /\b(fyi|for context|heads up|to clarify|clarification|correction|actually|note that)\b/i,
-    /\b(i meant|what i meant|not asking you to|no action needed)\b/i,
-];
-const QUESTION_PATTERNS = [
-    /\?$/,
-    /\b(can|could|do|does|did|is|are|was|were|why|how|what|when|where|which|who|should|would)\b/i,
-];
-export function classifyFollowupIntent(input) {
-    const text = input.trim();
+import { getThreadTurns } from "./codex-thread-utils.js";
+import { isThreadMaterializingError } from "./codex-thread-errors.js";
+import { extractFirstJsonObject, safeJsonParse } from "./utils.js";
+const FOLLOWUP_INTENT_TIMEOUT_MS = 45_000;
+const FOLLOWUP_INTENT_POLL_MS = 1_000;
+export const FOLLOWUP_INTENT_MIN_CONFIDENCE = 0.55;
+export class CodexFollowupIntentClassifier {
+    codex;
+    logger;
+    constructor(codex, logger) {
+        this.codex = codex;
+        this.logger = logger;
+    }
+    async classify(input, context) {
+        if (!input.trim()) {
+            return lowConfidenceFollowupIntent("Empty follow-up text.");
+        }
+        try {
+            const thread = await this.codex.startThreadForFollowupIntent();
+            const turn = await this.codex.startTurn({
+                threadId: thread.id,
+                ...(thread.cwd ? { cwd: thread.cwd } : {}),
+                input: buildFollowupIntentPrompt(input, context),
+            });
+            const completedThread = await this.waitForTurn(thread.id, turn.turnId);
+            const completedTurn = getThreadTurns(completedThread).find((entry) => entry.id === turn.turnId);
+            const latestMessage = completedTurn?.items
+                .filter((item) => item.type === "agentMessage")
+                .at(-1)?.text;
+            const parsed = parseFollowupIntentClassification(latestMessage);
+            if (!parsed) {
+                this.logger.warn({ threadId: thread.id, turnId: turn.turnId }, "Follow-up intent classifier returned invalid JSON");
+                return lowConfidenceFollowupIntent("Classifier returned invalid JSON.");
+            }
+            if (parsed.confidence < FOLLOWUP_INTENT_MIN_CONFIDENCE) {
+                return {
+                    intent: "unknown_needs_ack",
+                    confidence: parsed.confidence,
+                    reason: `Low confidence (${parsed.confidence}): ${parsed.reason}`,
+                };
+            }
+            return parsed;
+        }
+        catch (error) {
+            this.logger.warn({ error: error instanceof Error ? error.message : String(error) }, "Follow-up intent classification failed");
+            return lowConfidenceFollowupIntent("Classifier unavailable.");
+        }
+    }
+    async waitForTurn(threadId, turnId) {
+        const deadline = Date.now() + FOLLOWUP_INTENT_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            let thread;
+            try {
+                thread = await this.codex.readThread(threadId, true);
+            }
+            catch (error) {
+                if (isThreadMaterializingError(error)) {
+                    await new Promise((resolve) => setTimeout(resolve, FOLLOWUP_INTENT_POLL_MS));
+                    continue;
+                }
+                throw error;
+            }
+            const turn = getThreadTurns(thread).find((entry) => entry.id === turnId);
+            if (turn?.status === "completed") {
+                return thread;
+            }
+            if (turn?.status === "failed" || turn?.status === "interrupted") {
+                throw new Error(`Follow-up intent turn ${turnId} ended with status ${turn.status}`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, FOLLOWUP_INTENT_POLL_MS));
+        }
+        throw new Error(`Follow-up intent timed out after ${FOLLOWUP_INTENT_TIMEOUT_MS}ms`);
+    }
+}
+export function buildFollowupIntentPrompt(input, context) {
+    return [
+        "PatchRelay follow-up intent classification",
+        "",
+        "Classify one human follow-up so PatchRelay can route it through an explicit workflow state.",
+        "Do not solve the task, draft a reply, or start work. Infer ordinary natural-language intent from the text and state facts.",
+        "Return exactly one JSON object and no extra prose.",
+        "",
+        "Schema:",
+        "{",
+        '  "intent": "stop" | "status" | "resume_or_retry" | "implementation_instruction" | "answer_to_question" | "context_only" | "unknown_needs_ack",',
+        '  "confidence": 0.0,',
+        '  "reason": "one short sentence"',
+        "}",
+        "",
+        "Intent definitions:",
+        '- "stop": the user asks PatchRelay to halt or cancel active work.',
+        '- "status": the user asks only for current state, progress, or what happened.',
+        '- "resume_or_retry": the user asks PatchRelay to continue, resume, retry, or run again.',
+        '- "implementation_instruction": the user gives work instructions, constraints, review feedback, or asks for code-changing work.',
+        '- "answer_to_question": the user is answering a PatchRelay question or unblocking awaiting-input work.',
+        '- "context_only": the user provides background that should not start idle work by itself.',
+        '- "unknown_needs_ack": the text is too ambiguous to route confidently.',
+        "",
+        "Routing facts:",
+        `- Source: ${context.source}`,
+        `- Active run type: ${context.activeRunType ?? "none"}`,
+        `- Factory state: ${context.factoryState ?? "unknown"}`,
+        `- Direct reply to outstanding PatchRelay question: ${context.directReply ? "yes" : "no"}`,
+        `- Delegated to PatchRelay: ${context.delegatedToPatchRelay ? "yes" : "no"}`,
+        `- PR review state: ${context.prReviewState ?? "none"}`,
+        `- Explicit PatchRelay wake context: ${context.explicitWakeIntent ? "yes" : "no"}`,
+        "",
+        "Follow-up text:",
+        input.trim(),
+    ].join("\n");
+}
+export function parseFollowupIntentClassification(text) {
     if (!text)
-        return "clarification";
-    if (matchesAny(text, STOP_PATTERNS))
-        return "stop";
-    if (matchesAny(text, RETRY_PATTERNS))
-        return "retry";
-    if (matchesAny(text, STATUS_PATTERNS))
-        return "status";
-    if (matchesAny(text, IMPLEMENTATION_PATTERNS))
-        return "implementation_request";
-    if (matchesAny(text, CLARIFICATION_PATTERNS))
-        return "clarification";
-    if (matchesAny(text, QUESTION_PATTERNS))
-        return "question";
-    return "clarification";
-}
-export function followupIntentQueuesWork(intent) {
-    return intent === "implementation_request" || intent === "retry";
-}
-export function followupIntentIsNonActionable(intent) {
-    return intent === "status" || intent === "question" || intent === "clarification";
-}
-function matchesAny(text, patterns) {
-    return patterns.some((pattern) => pattern.test(text));
+        return undefined;
+    const json = extractFirstJsonObject(text) ?? text;
+    const parsed = safeJsonParse(json);
+    if (!parsed)
+        return undefined;
+    const intent = parsed.intent;
+    const confidence = parsed.confidence;
+    const reason = parsed.reason;
+    if (!isFollowupIntent(intent))
+        return undefined;
+    if (typeof confidence !== "number" || !Number.isFinite(confidence))
+        return undefined;
+    if (typeof reason !== "string" || !reason.trim())
+        return undefined;
+    return {
+        intent,
+        confidence: Math.max(0, Math.min(1, confidence)),
+        reason: reason.trim().slice(0, 240),
+    };
+}
+export function lowConfidenceFollowupIntent(reason) {
+    return {
+        intent: "unknown_needs_ack",
+        confidence: 0,
+        reason,
+    };
+}
+export function followupIntentQueuesWork(classification) {
+    const intent = typeof classification === "string" ? classification : classification.intent;
+    return intent === "implementation_instruction"
+        || intent === "resume_or_retry"
+        || intent === "answer_to_question";
+}
+export function followupIntentIsNonActionable(classification) {
+    const intent = typeof classification === "string" ? classification : classification.intent;
+    return intent === "status"
+        || intent === "context_only"
+        || intent === "unknown_needs_ack";
+}
+export function followupIntentShouldSteerActiveRun(classification) {
+    const intent = typeof classification === "string" ? classification : classification.intent;
+    return intent === "implementation_instruction"
+        || intent === "resume_or_retry"
+        || intent === "answer_to_question"
+        || intent === "context_only"
+        || intent === "unknown_needs_ack";
+}
+function isFollowupIntent(value) {
+    return value === "stop"
+        || value === "status"
+        || value === "resume_or_retry"
+        || value === "implementation_instruction"
+        || value === "answer_to_question"
+        || value === "context_only"
+        || value === "unknown_needs_ack";
 }

package/dist/issue-session-events.js

@@ -9,6 +9,7 @@ const TERMINAL_SESSION_EVENTS = new Set([
 ]);
 const NON_ACTIONABLE_SESSION_EVENTS = new Set([
     "delegation_observed",
+    "prompt_delivered",
     "run_released_authority",
 ]);
 const RUN_TYPES = new Set(["implementation", "main_repair", "review_fix", "branch_upkeep", "ci_repair", "queue_repair"]);
@@ -117,6 +118,17 @@ export function deriveSessionWakePlan(issue, events) {
                         ...(typeof payload?.author === "string" ? { author: payload.author } : {}),
                     });
                 }
+                if (payload?.replacementPrRequired === true) {
+                    context.replacementPrRequired = true;
+                    if (typeof payload.previousPrNumber === "number")
+                        context.previousPrNumber = payload.previousPrNumber;
+                    if (typeof payload.previousPrUrl === "string")
+                        context.previousPrUrl = payload.previousPrUrl;
+                    if (typeof payload.previousPrState === "string")
+                        context.previousPrState = payload.previousPrState;
+                    if (typeof payload.previousPrHeadSha === "string")
+                        context.previousPrHeadSha = payload.previousPrHeadSha;
+                }
                 if (event.eventType === "followup_prompt"
                     || event.eventType === "followup_comment"
                     || event.eventType === "operator_prompt") {