patchrelay 0.38.0 → 0.38.2

package/dist/github-webhook-state-projector.js

@@ -0,0 +1,245 @@
+import { createGitHubCiSnapshotResolver, createGitHubFailureContextResolver } from "./github-failure-context.js";
+import { buildClosedPrCleanupFields } from "./pr-state.js";
+import { canClearFailureProvenance, deriveImmediatePrCheckStatus, getGateCheckNames, getPrimaryGateCheckName, isGateCheckEvent, isMetadataOnlyCheckEvent, isQueueEvictionFailure, isStaleGateEvent, isSettledBranchFailure, resolveGitHubFactoryStateForEvent, } from "./github-webhook-policy.js";
+import { buildGitHubQueueFailureContext, resolveGitHubBranchFailureContext, } from "./github-webhook-failure-context.js";
+import { emitGitHubLinearActivity, syncGitHubLinearSession } from "./github-linear-session-sync.js";
+import { buildQueueRepairContextFromEvent } from "./merge-queue-incident.js";
+export async function projectGitHubWebhookState(deps, issue, event, project, linkedBy) {
+    const failureContextResolver = deps.failureContextResolver ?? createGitHubFailureContextResolver();
+    const ciSnapshotResolver = deps.ciSnapshotResolver ?? createGitHubCiSnapshotResolver();
+    const immediateCheckStatus = deriveImmediatePrCheckStatus(issue, event, project);
+    deps.db.issues.upsertIssue({
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        ...(event.prNumber !== undefined ? { prNumber: event.prNumber } : {}),
+        ...(event.prUrl !== undefined ? { prUrl: event.prUrl } : {}),
+        ...(event.prState !== undefined ? { prState: event.prState } : {}),
+        ...(event.headSha !== undefined ? { prHeadSha: event.headSha } : {}),
+        ...(event.prAuthorLogin !== undefined ? { prAuthorLogin: event.prAuthorLogin } : {}),
+        ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
+        ...(immediateCheckStatus !== undefined ? { prCheckStatus: immediateCheckStatus } : {}),
+        ...(linkedBy === "issue_key" ? { branchName: event.branchName } : {}),
+        ...(event.reviewState === "changes_requested"
+            ? { lastBlockingReviewHeadSha: event.reviewCommitId ?? event.headSha ?? null }
+            : event.reviewState === "approved"
+                ? { lastBlockingReviewHeadSha: null }
+                : {}),
+        ...(event.triggerEvent === "pr_closed"
+            ? buildClosedPrCleanupFields()
+            : {}),
+    });
+    await updateGitHubCiSnapshot(deps, issue, event, project, ciSnapshotResolver);
+    await updateGitHubFailureProvenance(deps, issue, event, project, failureContextResolver);
+    const queueEvictionCheck = isQueueEvictionFailure(issue, event, project);
+    if (!isMetadataOnlyCheckEvent(event) || queueEvictionCheck) {
+        const afterMetadata = deps.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        const newState = resolveGitHubFactoryStateForEvent(afterMetadata, event, project);
+        if (newState && newState !== afterMetadata.factoryState) {
+            deps.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                factoryState: newState,
+            });
+            deps.logger.info({ issueKey: issue.issueKey, from: afterMetadata.factoryState, to: newState, trigger: event.triggerEvent }, "Factory state transition from GitHub event");
+            const transitionedIssue = deps.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+            void emitGitHubLinearActivity({
+                linearProvider: deps.linearProvider,
+                logger: deps.logger,
+                feed: deps.feed,
+                issue: transitionedIssue,
+                newState,
+                event,
+            });
+            void syncGitHubLinearSession({
+                config: deps.config,
+                linearProvider: deps.linearProvider,
+                logger: deps.logger,
+                issue: transitionedIssue,
+            });
+        }
+    }
+    const freshIssue = deps.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+    if (event.triggerEvent === "pr_synchronize" && !freshIssue.activeRunId) {
+        deps.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ciRepairAttempts: 0,
+            queueRepairAttempts: 0,
+            lastGitHubFailureSource: null,
+            lastGitHubFailureHeadSha: null,
+            lastGitHubFailureSignature: null,
+            lastGitHubFailureCheckName: null,
+            lastGitHubFailureCheckUrl: null,
+            lastGitHubFailureContextJson: null,
+            lastGitHubFailureAt: null,
+            lastGitHubCiSnapshotHeadSha: event.headSha ?? null,
+            lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
+            lastGitHubCiSnapshotGateCheckStatus: "pending",
+            lastGitHubCiSnapshotJson: null,
+            lastGitHubCiSnapshotSettledAt: null,
+            lastQueueIncidentJson: null,
+            lastAttemptedFailureHeadSha: null,
+            lastAttemptedFailureSignature: null,
+        });
+    }
+    deps.logger.info({ issueKey: issue.issueKey, branchName: event.branchName, triggerEvent: event.triggerEvent, prNumber: event.prNumber }, "GitHub webhook: updated issue PR state");
+    deps.feed?.publish({
+        level: event.triggerEvent.includes("failed") ? "warn" : "info",
+        kind: "github",
+        issueKey: freshIssue.issueKey,
+        projectId: freshIssue.projectId,
+        stage: freshIssue.factoryState,
+        status: event.triggerEvent,
+        summary: `GitHub: ${event.triggerEvent}${event.prNumber ? ` on PR #${event.prNumber}` : ""}`,
+        detail: event.checkName ?? event.reviewBody?.slice(0, 200) ?? undefined,
+    });
+    return freshIssue;
+}
+async function updateGitHubCiSnapshot(deps, issue, event, project, ciSnapshotResolver) {
+    if (event.triggerEvent === "pr_merged") {
+        deps.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            lastGitHubCiSnapshotHeadSha: null,
+            lastGitHubCiSnapshotGateCheckName: null,
+            lastGitHubCiSnapshotGateCheckStatus: null,
+            lastGitHubCiSnapshotJson: null,
+            lastGitHubCiSnapshotSettledAt: null,
+        });
+        return;
+    }
+    if (event.triggerEvent === "pr_synchronize") {
+        deps.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            prCheckStatus: "pending",
+            lastGitHubCiSnapshotHeadSha: event.headSha ?? null,
+            lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
+            lastGitHubCiSnapshotGateCheckStatus: "pending",
+            lastGitHubCiSnapshotJson: null,
+            lastGitHubCiSnapshotSettledAt: null,
+        });
+        return;
+    }
+    if (issue.prState !== "open")
+        return;
+    if (event.eventSource !== "check_run" && event.eventSource !== "check_suite")
+        return;
+    if (isQueueEvictionFailure(issue, event, project))
+        return;
+    if (!isGateCheckEvent(event, project))
+        return;
+    if (isStaleGateEvent(issue, event))
+        return;
+    if (event.triggerEvent === "check_pending") {
+        deps.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            prCheckStatus: "pending",
+            lastGitHubCiSnapshotHeadSha: event.headSha ?? issue.lastGitHubCiSnapshotHeadSha ?? null,
+            lastGitHubCiSnapshotGateCheckName: event.checkName ?? getPrimaryGateCheckName(project),
+            lastGitHubCiSnapshotGateCheckStatus: "pending",
+            lastGitHubCiSnapshotJson: null,
+            lastGitHubCiSnapshotSettledAt: null,
+        });
+        return;
+    }
+    const snapshot = await ciSnapshotResolver.resolve({
+        repoFullName: project?.github?.repoFullName ?? event.repoFullName,
+        event,
+        gateCheckNames: getGateCheckNames(project),
+    });
+    if (!snapshot) {
+        deps.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            lastGitHubCiSnapshotHeadSha: event.headSha ?? issue.lastGitHubCiSnapshotHeadSha ?? null,
+            lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
+            lastGitHubCiSnapshotGateCheckStatus: "pending",
+            lastGitHubCiSnapshotJson: null,
+            lastGitHubCiSnapshotSettledAt: null,
+        });
+        deps.logger.warn({ issueKey: issue.issueKey, repoFullName: project?.github?.repoFullName ?? event.repoFullName, headSha: event.headSha }, "Could not resolve settled CI snapshot; waiting before CI repair");
+        deps.feed?.publish({
+            level: "warn",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "ci_snapshot_unavailable",
+            summary: `Could not resolve settled ${getPrimaryGateCheckName(project)} snapshot; waiting before CI repair`,
+        });
+        return;
+    }
+    deps.db.issues.upsertIssue({
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        prCheckStatus: snapshot.gateCheckStatus,
+        lastGitHubCiSnapshotHeadSha: snapshot.headSha,
+        lastGitHubCiSnapshotGateCheckName: snapshot.gateCheckName ?? getPrimaryGateCheckName(project),
+        lastGitHubCiSnapshotGateCheckStatus: snapshot.gateCheckStatus,
+        lastGitHubCiSnapshotJson: JSON.stringify(snapshot),
+        lastGitHubCiSnapshotSettledAt: snapshot.settledAt ?? null,
+    });
+}
+async function updateGitHubFailureProvenance(deps, issue, event, project, failureContextResolver) {
+    const isQueueEvictionCheck = isQueueEvictionFailure(issue, event, project);
+    if (event.triggerEvent === "check_failed" && issue.prState === "open") {
+        const source = isQueueEvictionCheck
+            ? "queue_eviction"
+            : "branch_ci";
+        if (source === "branch_ci" && !isSettledBranchFailure(deps.db, issue, event, project)) {
+            return;
+        }
+        const failureContext = source === "queue_eviction"
+            ? buildGitHubQueueFailureContext(event, project, buildQueueRepairContextFromEvent(event))
+            : await resolveGitHubBranchFailureContext({
+                db: deps.db,
+                issue,
+                event,
+                project,
+                failureContextResolver,
+            });
+        deps.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            lastGitHubFailureSource: source,
+            lastGitHubFailureHeadSha: failureContext.failureHeadSha ?? event.headSha ?? null,
+            lastGitHubFailureSignature: failureContext.failureSignature ?? null,
+            lastGitHubFailureCheckName: failureContext.checkName ?? event.checkName ?? null,
+            lastGitHubFailureCheckUrl: failureContext.checkUrl ?? event.checkUrl ?? null,
+            lastGitHubFailureContextJson: JSON.stringify(failureContext),
+            lastGitHubFailureAt: new Date().toISOString(),
+            ...(source === "queue_eviction"
+                ? {
+                    lastQueueSignalAt: new Date().toISOString(),
+                    lastQueueIncidentJson: JSON.stringify(buildQueueRepairContextFromEvent(event)),
+                }
+                : {
+                    lastQueueIncidentJson: null,
+                }),
+        });
+        return;
+    }
+    if ((event.triggerEvent === "check_passed" && (!isMetadataOnlyCheckEvent(event) || isQueueEvictionFailure(issue, event, project) || isGateCheckEvent(event, project)))
+        || event.triggerEvent === "pr_synchronize"
+        || event.triggerEvent === "pr_merged") {
+        if (event.triggerEvent === "check_passed" && !canClearFailureProvenance(issue, event, project)) {
+            return;
+        }
+        deps.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            lastGitHubFailureSource: null,
+            lastGitHubFailureHeadSha: null,
+            lastGitHubFailureSignature: null,
+            lastGitHubFailureCheckName: null,
+            lastGitHubFailureCheckUrl: null,
+            lastGitHubFailureContextJson: null,
+            lastGitHubFailureAt: null,
+            lastQueueIncidentJson: null,
+            lastAttemptedFailureHeadSha: null,
+            lastAttemptedFailureSignature: null,
+        });
+    }
+}

package/dist/github-webhook-terminal-handler.js

@@ -0,0 +1,111 @@
+import { resolveClosedPrDisposition, resolveClosedPrFactoryState } from "./pr-state.js";
+import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
+import { syncGitHubLinearSession } from "./github-linear-session-sync.js";
+export async function handleGitHubTerminalPrEvent(params) {
+    const { db, linearProvider, enqueueIssue, logger, codex, issue, event, config } = params;
+    const eventType = event.triggerEvent === "pr_merged" ? "pr_merged" : "pr_closed";
+    db.issueSessions.appendIssueSessionEvent({
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        eventType,
+        dedupeKey: [eventType, issue.prNumber ?? event.prNumber ?? "unknown-pr", issue.prHeadSha ?? event.headSha ?? "unknown-sha"].join("::"),
+    });
+    db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+    const run = issue.activeRunId ? db.runs.getRunById(issue.activeRunId) : undefined;
+    if (run?.threadId && run.turnId) {
+        try {
+            await codex.steerTurn({
+                threadId: run.threadId,
+                turnId: run.turnId,
+                input: event.triggerEvent === "pr_merged"
+                    ? "STOP: The pull request has already merged. Stop working immediately and exit without making further changes."
+                    : "STOP: The pull request was closed. Stop working immediately and exit without making further changes.",
+            });
+        }
+        catch (error) {
+            logger.warn({ issueKey: issue.issueKey, runId: run.id, error: error instanceof Error ? error.message : String(error) }, "Failed to steer active run after terminal PR event");
+        }
+    }
+    const commitTerminalUpdate = () => {
+        if (run) {
+            db.runs.finishRun(run.id, {
+                status: "released",
+                failureReason: event.triggerEvent === "pr_merged"
+                    ? "Pull request merged during active run"
+                    : "Pull request closed during active run",
+            });
+        }
+        const terminalFactoryState = event.triggerEvent === "pr_merged"
+            ? "done"
+            : resolveClosedPrFactoryState(issue);
+        db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            activeRunId: null,
+            factoryState: terminalFactoryState,
+        });
+    };
+    const activeLease = db.issueSessions.getActiveIssueSessionLease(issue.projectId, issue.linearIssueId);
+    if (activeLease) {
+        db.issueSessions.withIssueSessionLease(issue.projectId, issue.linearIssueId, activeLease.leaseId, commitTerminalUpdate);
+    }
+    else {
+        db.transaction(commitTerminalUpdate);
+    }
+    db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
+    const updatedIssue = db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+    if (event.triggerEvent === "pr_closed" && resolveClosedPrDisposition(issue) === "redelegate") {
+        db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "delegated",
+            dedupeKey: `github_pr_closed:implementation:${issue.linearIssueId}`,
+        });
+        if (db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+            enqueueIssue(issue.projectId, issue.linearIssueId);
+        }
+    }
+    if (event.triggerEvent === "pr_merged") {
+        await completeLinearIssueAfterMerge(params, updatedIssue);
+    }
+    void syncGitHubLinearSession({
+        config,
+        linearProvider,
+        logger,
+        issue: updatedIssue,
+    });
+}
+async function completeLinearIssueAfterMerge(params, issue) {
+    const linear = await params.linearProvider.forProject(issue.projectId).catch(() => undefined);
+    if (!linear)
+        return;
+    try {
+        const liveIssue = await linear.getIssue(issue.linearIssueId);
+        const targetState = resolvePreferredCompletedLinearState(liveIssue);
+        if (!targetState) {
+            params.logger.warn({ issueKey: issue.issueKey }, "Could not find a completed Linear workflow state after merge");
+            return;
+        }
+        const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
+        if (normalizedCurrent === targetState.trim().toLowerCase()) {
+            params.db.issues.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+                ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+            });
+            return;
+        }
+        const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+        params.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
+            ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        params.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to move merged issue to a completed Linear state");
+    }
+}

package/dist/github-webhooks.js

@@ -114,9 +114,25 @@ function normalizePullRequestReviewEvent(payload, repoFullName) {
     };
 }
 function normalizeCheckSuiteEvent(payload, repoFullName) {
-    if (payload.action !== "completed")
-        return undefined;
     const suite = payload.check_suite;
+    if (payload.action !== "completed") {
+        if (payload.action !== "requested" && payload.action !== "rerequested" && payload.action !== "in_progress") {
+            return undefined;
+        }
+        const pr = suite.pull_requests?.[0];
+        const branchName = pr?.head.ref ?? suite.head_branch ?? "";
+        if (!branchName)
+            return undefined;
+        return {
+            triggerEvent: "check_pending",
+            repoFullName,
+            branchName,
+            headSha: suite.head_sha,
+            prNumber: pr?.number,
+            checkStatus: "pending",
+            eventSource: "check_suite",
+        };
+    }
     const conclusion = suite.conclusion?.toLowerCase();
     const pr = suite.pull_requests?.[0];
     const branchName = pr?.head.ref ?? suite.head_branch ?? "";
@@ -134,9 +150,28 @@ function normalizeCheckSuiteEvent(payload, repoFullName) {
     };
 }
 function normalizeCheckRunEvent(payload, repoFullName) {
-    if (payload.action !== "completed")
-        return undefined;
     const run = payload.check_run;
+    if (payload.action !== "completed") {
+        if (payload.action !== "requested" && payload.action !== "rerequested" && payload.action !== "in_progress") {
+            return undefined;
+        }
+        const pr = run.check_suite?.pull_requests?.[0];
+        const branchName = pr?.head.ref ?? run.check_suite?.head_branch ?? "";
+        if (!branchName)
+            return undefined;
+        return {
+            triggerEvent: "check_pending",
+            repoFullName,
+            branchName,
+            headSha: run.head_sha,
+            prNumber: pr?.number,
+            checkStatus: "pending",
+            checkName: run.name,
+            checkUrl: run.html_url,
+            checkDetailsUrl: run.details_url,
+            eventSource: "check_run",
+        };
+    }
     const conclusion = run.conclusion?.toLowerCase();
     const pr = run.check_suite?.pull_requests?.[0];
     const branchName = pr?.head.ref ?? run.check_suite?.head_branch ?? "";

package/dist/http.js

@@ -314,6 +314,23 @@ export async function buildHttpServer(config, service, logger) {
             }
             return reply.send({ ok: true, ...result });
         });
+        app.post("/api/issues/:issueKey/close", async (request, reply) => {
+            const issueKey = request.params.issueKey;
+            const body = request.body;
+            const result = await service.closeIssue(issueKey, {
+                failed: body?.failed === true,
+                ...(typeof body?.reason === "string" && body.reason.trim()
+                    ? { reason: body.reason.trim() }
+                    : {}),
+            });
+            if (!result) {
+                return reply.code(404).send({ ok: false, reason: "issue_not_found" });
+            }
+            if ("error" in result) {
+                return reply.code(409).send({ ok: false, reason: result.error });
+            }
+            return reply.send({ ok: true, ...result });
+        });
         app.get("/api/installations", async (_request, reply) => {
             return reply.send({ ok: true, installations: service.listLinearInstallations() });
         });

package/dist/idle-reconciliation.js

@@ -4,8 +4,8 @@ import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
 import { buildClosedPrCleanupFields, resolveClosedPrDisposition } from "./pr-state.js";
+import { getReviewFixBudget } from "./run-budgets.js";
 import { execCommand } from "./utils.js";
-const DEFAULT_REVIEW_FIX_BUDGET = 12;
 function isFailingCheckStatus(status) {
     return status === "failed" || status === "failure";
 }
@@ -510,13 +510,15 @@ export class IdleIssueReconciler {
             if (issue.delegatedToPatchRelay
                 && (issue.factoryState === "escalated" || issue.factoryState === "failed")
                 && (reactiveIntent?.runType === "review_fix" || reactiveIntent?.runType === "branch_upkeep")) {
-                if (issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
+                const reviewFixBudget = getReviewFixBudget(project);
+                if (issue.reviewFixAttempts >= reviewFixBudget) {
                     this.logger.debug({
                         issueKey: issue.issueKey,
                         prNumber: issue.prNumber,
                         from: issue.factoryState,
                         runType: reactiveIntent.runType,
                         reviewFixAttempts: issue.reviewFixAttempts,
+                        reviewFixBudget,
                     }, "Reconciliation: leaving terminal requested-changes issue escalated because the repair budget is exhausted");
                     return;
                 }

package/dist/issue-overview-query.js

@@ -1,5 +1,6 @@
 import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { isIssueSessionReadyForExecution } from "./issue-session.js";
+import { getLegacyIssueOverview } from "./legacy-issue-overview.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
 export function parseStageReport(reportJson, runStatus) {
@@ -25,7 +26,13 @@ export class IssueOverviewQuery {
     async getIssueOverview(issueKey) {
         const session = this.db.issueSessions.getIssueSessionByKey(issueKey);
         if (!session) {
-            return await this.getLegacyIssueOverview(issueKey);
+            return await getLegacyIssueOverview({
+                db: this.db,
+                issueKey,
+                runStatusProvider: this.runStatusProvider,
+                buildRuns: (projectId, linearIssueId) => this.buildRuns(projectId, linearIssueId),
+                readLiveThread: (run) => this.readLiveThread(run),
+            });
         }
         return await this.getSessionIssueOverview(issueKey, session);
     }
@@ -66,62 +73,6 @@ export class IssueOverviewQuery {
             })(),
         }));
     }
-    async getLegacyIssueOverview(issueKey) {
-        const legacy = this.db.getIssueOverview(issueKey);
-        if (!legacy)
-            return undefined;
-        const issueRecord = this.db.issues.getIssueByKey(issueKey);
-        const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
-        const activeRun = activeStatus?.run ?? legacy.activeRun;
-        const latestRun = this.db.runs.getLatestRunForIssue(legacy.issue.projectId, legacy.issue.linearIssueId);
-        const latestEvent = this.db.issueSessions.listIssueSessionEvents(legacy.issue.projectId, legacy.issue.linearIssueId, { limit: 1 }).at(-1);
-        const runs = this.buildRuns(legacy.issue.projectId, legacy.issue.linearIssueId);
-        const runCount = runs.length;
-        const liveThread = await this.readLiveThread(activeRun);
-        const statusNote = issueRecord
-            ? deriveIssueStatusNote({
-                issue: issueRecord,
-                latestRun,
-                latestEvent,
-                failureSummary: legacy.issue.latestFailureSummary,
-                blockedByKeys: legacy.issue.blockedByKeys,
-                waitingReason: legacy.issue.waitingReason,
-            })
-            : legacy.issue.statusNote;
-        return {
-            issue: {
-                ...legacy.issue,
-                ...(statusNote ? { statusNote } : {}),
-            },
-            ...(activeRun ? { activeRun } : {}),
-            ...(latestRun ? { latestRun } : {}),
-            ...(liveThread ? { liveThread } : {}),
-            ...(runs.length > 0 ? { runs } : {}),
-            ...(issueRecord
-                ? {
-                    issueContext: {
-                        ...(issueRecord.description ? { description: issueRecord.description } : {}),
-                        ...(issueRecord.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
-                        ...(issueRecord.url ? { issueUrl: issueRecord.url } : {}),
-                        ...(issueRecord.worktreePath ? { worktreePath: issueRecord.worktreePath } : {}),
-                        ...(issueRecord.branchName ? { branchName: issueRecord.branchName } : {}),
-                        ...(issueRecord.prUrl ? { prUrl: issueRecord.prUrl } : {}),
-                        ...(issueRecord.priority != null ? { priority: issueRecord.priority } : {}),
-                        ...(issueRecord.estimate != null ? { estimate: issueRecord.estimate } : {}),
-                        ciRepairAttempts: issueRecord.ciRepairAttempts,
-                        queueRepairAttempts: issueRecord.queueRepairAttempts,
-                        reviewFixAttempts: issueRecord.reviewFixAttempts,
-                        ...(legacy.issue.latestFailureSource ? { latestFailureSource: legacy.issue.latestFailureSource } : {}),
-                        ...(legacy.issue.latestFailureHeadSha ? { latestFailureHeadSha: legacy.issue.latestFailureHeadSha } : {}),
-                        ...(legacy.issue.latestFailureCheckName ? { latestFailureCheckName: legacy.issue.latestFailureCheckName } : {}),
-                        ...(legacy.issue.latestFailureStepName ? { latestFailureStepName: legacy.issue.latestFailureStepName } : {}),
-                        ...(legacy.issue.latestFailureSummary ? { latestFailureSummary: legacy.issue.latestFailureSummary } : {}),
-                        runCount,
-                    },
-                }
-                : {}),
-        };
-    }
     async getSessionIssueOverview(issueKey, session) {
         const issueRecord = this.db.issues.getIssueByKey(issueKey);
         const blockedBy = this.db.issues.listIssueDependencies(session.projectId, session.linearIssueId);

package/dist/issue-session-events.js

@@ -1,6 +1,7 @@
 import { sanitizeOperatorFacingText } from "./presentation-text.js";
 const TERMINAL_SESSION_EVENTS = new Set([
     "stop_requested",
+    "operator_closed",
     "undelegated",
     "issue_removed",
     "pr_closed",

package/dist/legacy-issue-overview.js

@@ -0,0 +1,58 @@
+import { deriveIssueStatusNote } from "./status-note.js";
+export async function getLegacyIssueOverview(params) {
+    const { db, issueKey, runStatusProvider, buildRuns, readLiveThread } = params;
+    const legacy = db.getIssueOverview(issueKey);
+    if (!legacy)
+        return undefined;
+    const issueRecord = db.issues.getIssueByKey(issueKey);
+    const activeStatus = await runStatusProvider.getActiveRunStatus(issueKey);
+    const activeRun = activeStatus?.run ?? legacy.activeRun;
+    const latestRun = db.runs.getLatestRunForIssue(legacy.issue.projectId, legacy.issue.linearIssueId);
+    const latestEvent = db.issueSessions.listIssueSessionEvents(legacy.issue.projectId, legacy.issue.linearIssueId, { limit: 1 }).at(-1);
+    const runs = buildRuns(legacy.issue.projectId, legacy.issue.linearIssueId);
+    const runCount = runs.length;
+    const liveThread = await readLiveThread(activeRun);
+    const statusNote = issueRecord
+        ? deriveIssueStatusNote({
+            issue: issueRecord,
+            latestRun,
+            latestEvent,
+            failureSummary: legacy.issue.latestFailureSummary,
+            blockedByKeys: legacy.issue.blockedByKeys,
+            waitingReason: legacy.issue.waitingReason,
+        })
+        : legacy.issue.statusNote;
+    return {
+        issue: {
+            ...legacy.issue,
+            ...(statusNote ? { statusNote } : {}),
+        },
+        ...(activeRun ? { activeRun } : {}),
+        ...(latestRun ? { latestRun } : {}),
+        ...(liveThread ? { liveThread } : {}),
+        ...(runs.length > 0 ? { runs } : {}),
+        ...(issueRecord
+            ? {
+                issueContext: {
+                    ...(issueRecord.description ? { description: issueRecord.description } : {}),
+                    ...(issueRecord.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
+                    ...(issueRecord.url ? { issueUrl: issueRecord.url } : {}),
+                    ...(issueRecord.worktreePath ? { worktreePath: issueRecord.worktreePath } : {}),
+                    ...(issueRecord.branchName ? { branchName: issueRecord.branchName } : {}),
+                    ...(issueRecord.prUrl ? { prUrl: issueRecord.prUrl } : {}),
+                    ...(issueRecord.priority != null ? { priority: issueRecord.priority } : {}),
+                    ...(issueRecord.estimate != null ? { estimate: issueRecord.estimate } : {}),
+                    ciRepairAttempts: issueRecord.ciRepairAttempts,
+                    queueRepairAttempts: issueRecord.queueRepairAttempts,
+                    reviewFixAttempts: issueRecord.reviewFixAttempts,
+                    ...(legacy.issue.latestFailureSource ? { latestFailureSource: legacy.issue.latestFailureSource } : {}),
+                    ...(legacy.issue.latestFailureHeadSha ? { latestFailureHeadSha: legacy.issue.latestFailureHeadSha } : {}),
+                    ...(legacy.issue.latestFailureCheckName ? { latestFailureCheckName: legacy.issue.latestFailureCheckName } : {}),
+                    ...(legacy.issue.latestFailureStepName ? { latestFailureStepName: legacy.issue.latestFailureStepName } : {}),
+                    ...(legacy.issue.latestFailureSummary ? { latestFailureSummary: legacy.issue.latestFailureSummary } : {}),
+                    runCount,
+                },
+            }
+            : {}),
+    };
+}

package/dist/linear-activity-key.js

@@ -0,0 +1,11 @@
+import { sanitizeOperatorFacingText } from "./presentation-text.js";
+export function computeLinearActivityKey(content) {
+    if (content.type === "action") {
+        const action = sanitizeOperatorFacingText(content.action) ?? content.action;
+        const parameter = sanitizeOperatorFacingText(content.parameter) ?? content.parameter;
+        const result = sanitizeOperatorFacingText(content.result);
+        return `action:${action}:${parameter}:${result ?? ""}`;
+    }
+    const body = sanitizeOperatorFacingText(content.body) ?? content.body;
+    return `${content.type}:${body}`;
+}

package/dist/linear-agent-session-client.js

@@ -1,5 +1,6 @@
 import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
+import { computeLinearActivityKey } from "./linear-activity-key.js";
 export class LinearAgentSessionClient {
     config;
     db;
@@ -36,11 +37,23 @@ export class LinearAgentSessionClient {
             if (!linear)
                 return;
             const allowEphemeral = content.type === "thought" || content.type === "action";
+            const ephemeral = options?.ephemeral && allowEphemeral;
+            const activityKey = ephemeral ? undefined : computeLinearActivityKey(content);
+            if (activityKey && syncedIssue.lastLinearActivityKey === activityKey) {
+                return;
+            }
             await linear.createAgentActivity({
                 agentSessionId: syncedIssue.agentSessionId,
                 content,
-                ...(options?.ephemeral && allowEphemeral ? { ephemeral: true } : {}),
+                ...(ephemeral ? { ephemeral: true } : {}),
             });
+            if (activityKey) {
+                this.db.issues.upsertIssue({
+                    projectId: syncedIssue.projectId,
+                    linearIssueId: syncedIssue.linearIssueId,
+                    lastLinearActivityKey: activityKey,
+                });
+            }
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);